home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 4 / Amiga Tools 4.iso / tools / dfue / term 4.6(?) / extras / source / gtlayout-source.lha / gtlayout.doc < prev    next >
Text File  |  1996-03-18  |  128KB  |  3,824 lines
  1. TABLE OF CONTENTS
  2.  
  3. gtlayout.library/--background--
  4. gtlayout.library/--version--
  5. gtlayout.library/LT_Activate
  6. gtlayout.library/LT_BeginRefresh
  7. gtlayout.library/LT_BuildA
  8. gtlayout.library/LT_CreateHandleTagList
  9. gtlayout.library/LT_DeleteHandle
  10. gtlayout.library/LT_DeleteWindowLock
  11. gtlayout.library/LT_DisposeMenu
  12. gtlayout.library/LT_EndGroup
  13. gtlayout.library/LT_EndRefresh
  14. gtlayout.library/LT_Exit
  15. gtlayout.library/LT_FindMenuCommand
  16. gtlayout.library/LT_Fixed2String
  17. gtlayout.library/LT_FixedMult
  18. gtlayout.library/LT_GetAttributesA
  19. gtlayout.library/LT_GetCode
  20. gtlayout.library/LT_GetIMsg
  21. gtlayout.library/LT_GetMenuItem
  22. gtlayout.library/LT_HandleInput
  23. gtlayout.library/LT_Init
  24. gtlayout.library/LT_LabelChars
  25. gtlayout.library/LT_LabelWidth
  26. gtlayout.library/LT_LayoutMenusA
  27. gtlayout.library/LT_LevelWidth
  28. gtlayout.library/LT_LockWindow
  29. gtlayout.library/LT_MenuControlTagList
  30. gtlayout.library/LT_NewA
  31. gtlayout.library/LT_NewLevelWidth
  32. gtlayout.library/LT_NewMenuTagList
  33. gtlayout.library/LT_NewMenuTemplate
  34. gtlayout.library/LT_PressButton
  35. gtlayout.library/LT_RebuildTagList
  36. gtlayout.library/LT_Refresh
  37. gtlayout.library/LT_ReplyIMsg
  38. gtlayout.library/LT_SetAttributesA
  39. gtlayout.library/LT_ShowWindow
  40. gtlayout.library/LT_String2Fixed
  41. gtlayout.library/LT_UnlockWindow
  42. gtlayout.library/LT_UpdateStrings
  43. gtlayout.library/--background--               gtlayout.library/--background--
  44.  
  45.    NOTES
  46.     1. General information
  47.  
  48.     1.1 Purpose
  49.  
  50.     The GUI code included in this archive helps to create user interfaces
  51.     using gadtools.library with a minimum of effort. The code
  52.     automatically takes care of the font to be used, making the user
  53.     interface font independent. Localizing support is built right into
  54.     the code, just install a callback hook and pass numeric IDs for the
  55.     gadget labels: the code will invoke your hook in order to get the
  56.     text required. Keystroke activation of gadgets is also taken care
  57.     of, in fact the code will -- unless told not to do so -- assign keyboard
  58.     shortcuts to the gadgets created all on its own. Every effort has been
  59.     made to make the code reentrant, so it can be put into a shared library.
  60.     If a user interface does not fit onto a screen provisions are made to
  61.     choose a smaller font and to rescale the window contents until they fit.
  62.     Last but not least the user interface code offers transparent extensions
  63.     to the standard gadtools.library objects, such as LISTVIEW_KIND objects
  64.     which respond to double-clicks or STRING_KIND objects which can be used
  65.     to enter password text as they will not display the characters entered.
  66.  
  67.  
  68.     1.2 Distribution
  69.  
  70.     The code is *free*, you don't need to pay any money to use it, nor
  71.     do you need to quote my name in the documentation, the program or
  72.     anywhere else. You are allowed to make changes to the code, but if
  73.     you stumble across any bugs or even know how to fix them, please
  74.     let me know. It does not matter whether you intend to sell a program
  75.     to use the code, use the code in shareware, gift-ware, freeware or
  76.     etc.-ware programs: the code still remains royalty-free.
  77.  
  78.  
  79.     1.3 Caveats
  80.  
  81.     The code is pretty large, about 80K-100K bytes in size. Not all
  82.     gadtools.library type objects are supported, notably
  83.     GENERIC_KIND objects. The code is not as flexible as
  84.     gadtools.library, so certain things which are easily done using
  85.     gadtools.library may be pretty difficult or even impossible.
  86.     The code is written entirely in `C' and requires SAS/C to
  87.     compile. Some parts of the code are highly recursive; I haven't
  88.     tested how much stack they might require in certain cases,
  89.     but I recommend that you don't overuse the grouping feature.
  90.     The data structures required to create and maintain the
  91.     user interface are huge, a single window might require more
  92.     than 4K-6K of memory. Proportional font support only works
  93.     well starting with Kickstart v39 and up, v2.04 will probably
  94.     not look quite that pretty.
  95.  
  96.  
  97.     2. Programming
  98.  
  99.     2.1 Client libraries required for link library version
  100.  
  101.     You need to have SysBase and GadToolsBase initialized in order to make
  102.     use of the code, i.e. your code has to do
  103.     WaitPort()...GT_GetIMsg()...GT_ReplyIMsg all on its own. The code makes
  104.     use of the memory pools introduced in exec.library v39, but calls the
  105.     equivalent routines in amiga.lib. Note: as of this writing the pools
  106.     code in amiga.lib v40.14 is broken, so you need to link with Mike
  107.     Sinz' fixed pools.lib.
  108.  
  109.  
  110.     2.2 Invocation procedure
  111.  
  112.     The typical invocation procedure looks roughly like this:
  113.  
  114.        LT_Init();    // only for link library version
  115.        :
  116.        :
  117.           LT_CreateHandleTags();
  118.              LT_New();
  119.              :
  120.              :
  121.              LT_New();
  122.                 LT_Build();
  123.                    LT_HandleInput();
  124.           LT_DeleteHandle();
  125.        :
  126.        :
  127.        LT_Exit();    // only for link library version
  128.  
  129.     You need to call LT_Init() only once in your program, it will initialize
  130.     the libraries and global data structures required by the user interface
  131.     code. When you are finished with the user interface and your program is
  132.     about to exit you need to call LT_Exit() or memory will get lost.
  133.     Note that LT_Init() is not protected against multiple invocations. If
  134.     called repeatedly memory will get lost which can never be reclaimed.
  135.     However, LT_Exit() is protected against multiple invocations, you can
  136.     also call it before ever giving LT_Init() a call, but I doubt this
  137.     would make much sense. If you are using the shared gtlayout.library
  138.     no call to LT_Init()/LT_Exit() is necessary as these calls are already
  139.     wrapped into the library opening code.
  140.        Before you can actually start building a window layout a call to
  141.     LT_CreateHandleTags() needs to be made. You need to pass in a pointer
  142.     to the Screen your user interface window is to be opened on and,
  143.     optionally, a few tags to control the look and performance of the
  144.     interface. *Never* close the screen in question before calling
  145.     LT_DeleteHandle() or nasty things will happen. For public screens
  146.     the code will try to lock the screen in question. With the handle
  147.     LT_CreateHandleTags() returned you can call LT_New() to build the
  148.     user interface. When finished a call to LT_Build() will finally
  149.     open a window and place the gadgets inside. A pointer to the
  150.     Window created will be returned, ready to be used for the
  151.     WaitPort()...GT_GetIMsg()...LT_HandleInput()...GT_ReplyIMsg()
  152.     loop. When finished, a call to LT_DeleteHandle() will close the
  153.     window and release all the memory associated with it. The design
  154.     of the interface code is similar to the corresponding calls in
  155.     gadtools.library, i.e. you don't need to worry about LT_New()
  156.     failing to allocate memory for the objects required. When it comes
  157.     to LT_Build() the code will know about any trouble which would
  158.     show up during previous invocations of LT_New(). In essence,
  159.     if LT_Build() returns NULL something is wrong.
  160.  
  161.  
  162.     2.3 Hierarchic grouping
  163.  
  164.     The basic building block of the user interface is a group, either
  165.     a horizontal or a vertical group. Adding gadgets or other objects
  166.     to a horizontal group will place them side by side from left to
  167.     right. A vertical group causes objects to be place from top to
  168.     bottom in one straight line. Groups help to arrange objects
  169.     neatly stacked, centered and properly aligned with other
  170.     members of the group.
  171.  
  172.     MUCHO IMPORTANTE: there is a bug lurking in the code which I never
  173.     had the luck to find and fix. One would expect to create
  174.     user interface structures like this:
  175.  
  176.        <group start>
  177.           <button>
  178.           <list>
  179.           <group start>
  180.              <slider>
  181.              <text>
  182.           <group end>
  183.           <button>
  184.        <group end>
  185.  
  186.     However, it is in fact not possible to mix gadgets and groups.
  187.     Thus, the user interface structure would have to look like this:
  188.  
  189.        <group start>
  190.           <group start>
  191.              <button>
  192.              <list>
  193.           <group end>
  194.           <group start>
  195.              <slider>
  196.              <text>
  197.           <group end>
  198.           <group start>
  199.              <button>
  200.           <group end>
  201.        <group end>
  202.  
  203.     Or in other words: groups only mix with other groups.
  204.  
  205.     You build groups using three different object types. In this
  206.     context `object type' refers to a specific numeric value the
  207.     LT_New() routine knows which will cause it to add another leaf
  208.     to the user interface structure tree. Here is an example:
  209.  
  210.        struct LayoutHandle *Handle;
  211.  
  212.        if(Handle = LT_CreateHandleTags(NULL,
  213.           LAHN_AutoActivate,FALSE,
  214.        TAG_DONE))
  215.        {
  216.           struct Window *Window;
  217.  
  218.           LT_New(Handle,
  219.              LA_Type,      VERTICAL_KIND,  /* A vertical group. */
  220.              LA_LabelText, "Main group",   /* Group title text. */
  221.           TAG_DONE);
  222.           {
  223.              LT_New(Handle,
  224.                 LA_Type,      BUTTON_KIND, /* A plain button. */
  225.                 LA_LabelText, "A button",
  226.                 LA_ID,        11,
  227.              TAG_DONE);
  228.  
  229.              LT_New(Handle,
  230.                 LA_Type,      XBAR_KIND,   /* A separator bar. */
  231.              TAG_DONE);
  232.  
  233.              LT_New(Handle,
  234.                 LA_Type,      BUTTON_KIND, /* A plain button. */
  235.                 LA_LabelText, "Another button",
  236.                 LA_ID,        22,
  237.              TAG_DONE);
  238.  
  239.              LT_New(Handle,
  240.                 LA_Type,      END_KIND,    /* This ends the current group. */
  241.              TAG_DONE);
  242.           }
  243.  
  244.           if(Window = LT_Build(Handle,
  245.             LAWN_Title,     "Window title",
  246.             LAWN_IDCMP,     IDCMP_CLOSEWINDOW,
  247.             WA_CloseGadget, TRUE,
  248.           TAG_DONE))
  249.           {
  250.               struct IntuiMessage *Message;
  251.               ULONG                MsgQualifier,
  252.                                    MsgClass;
  253.               UWORD                MsgCode;
  254.               struct Gadget       *MsgGadget;
  255.               BOOL                 Done = FALSE;
  256.  
  257.               do
  258.               {
  259.                   WaitPort(Window->UserPort);
  260.  
  261.                   while(Message = GT_GetIMsg(Window->UserPort))
  262.                   {
  263.                      MsgClass     = Message->Class;
  264.                      MsgCode      = Message->Code;
  265.                      MsgQualifier = Message->Qualifier;
  266.                      MsgGadget    = Message->IAddress;
  267.  
  268.                      GT_ReplyIMsg(Message);
  269.  
  270.                      LT_HandleInput(Handle,MsgQualifier,&MsgClass,
  271.                          &MsgCode,&MsgGadget);
  272.  
  273.                      switch(MsgClass)
  274.                      {
  275.                         case IDCMP_CLOSEWINDOW:
  276.  
  277.                             Done = TRUE;
  278.                             break;
  279.  
  280.                         case IDCMP_GADGETUP:
  281.  
  282.                             switch(MsgGadget->GadgetID)
  283.                             {
  284.                                 case 11: printf("First gadget\n");
  285.                                          break;
  286.  
  287.                                 case 22: printf("Second gadget\n");
  288.                                          break;
  289.                             }
  290.  
  291.                             break;
  292.                      }
  293.                   }
  294.               }
  295.               while(!Done);
  296.           }
  297.  
  298.           LT_DeleteHandle(Handle);
  299.        }
  300.  
  301.     The example creates one single group, places a few objects inside,
  302.     calls the layout routine, handles the input and finally cleans
  303.     things up again. This example also shows that you *need* at
  304.     least one group in your tree (to form the root) in order to get
  305.     things to work.
  306.        The input loop requires you to call LT_HandleInput() in order
  307.     to get the user interface code to filter out certain events and
  308.     to update internal information. The data passed in must have
  309.     been processed via the gadtools.library routines. You *must not*
  310.     call LT_HandleInput() before GT_ReplyIMsg() is called since the
  311.     routine may call intuition.library and gadtools.library routines
  312.     which in turn might lead to a system lock-up if the message
  313.     has not been processed yet. The first thing to do after LT_HandleInput()
  314.     has done whatever was necessary to the data you passed in is
  315.     examine the MsgClass variable. The user interface code will
  316.     `fake' certain message events using the variables passed in,
  317.     *do not* use any other data gathered from the original
  318.     IntuiMessage. The MsgClass may include event types you did
  319.     not ask for, i.e. the IDCMP flags of the window opened
  320.     will be set according to the objects you added to the window.
  321.     Also, the IDCMP_IDCMPUPDATE message class will show up for
  322.     certain objects. More on this later in this document.
  323.  
  324.  
  325.     2.4 Setting and getting object attributes
  326.  
  327.     The mechanism to update and query object attributes does not
  328.     exactly match the familiar gadtools.library interface. In
  329.     fact, the routine to change gadget attributes will forward
  330.     the tagitem list passed in to gadtools.library/GT_SetGadgetAttrs().
  331.     On the other hand the routine to query object attributes does
  332.     not work like gadtools.library/GT_GetGadgetAttrs(). The
  333.     user interface code assumes that all objects it can handle and
  334.     create posess certain attributes unique to the type of the
  335.     object in question. For example, the unique attribute of a
  336.     STRING_KIND object would be a pointer to the string it
  337.     `contains'. The unique attribute of a SLIDER_KIND object is
  338.     the current slider position. The LT_GetAttributes() routine
  339.     will return this attribute, but also accept a tagitem list
  340.     to fill in for certain special tag values.
  341.  
  342.  
  343.     2.5 Extra data
  344.  
  345.     Once a LayoutHandle has been created the interface code will
  346.     provide you with a number of information concerning the screen
  347.     the handle has been attached to. This information includes
  348.     the DrawInfo structure of the screen, the VisualInfo data
  349.     and the Screen address. This information is read-only.
  350.  
  351.  
  352.     2.6 Menus
  353.  
  354.     With a LayoutHandle available a routine called LT_LayoutMenuTags()
  355.     will create a standard Intuition menu structure via gadtools.library
  356.     which can be passed to LT_Build(). Note that this
  357.     routine does not modify any data passed in, it does neither
  358.     attach the menu created to the LayoutHandle passed in,
  359.     nor does it change the NewMenu table.
  360.  
  361.  
  362.     2.7 Localization
  363.  
  364.     All object and menu creation routines support localization via
  365.     a Hook callback interface, i.e. you can pass a pointer to an
  366.     initialized Hook structure to LT_CreateHandleTags() which will
  367.     later be used to supply label and list text for objects
  368.     created. The Hook callback routine is called in the following
  369.     fashion:
  370.  
  371.        String = HookFunc(struct Hook *Hook,struct LayoutHandle *Handle,LONG ID)
  372.          D0                            A0                         A2        A1
  373.  
  374.     Or in other words: a locale string ID is passed in, the routine is supposed
  375.     to look up the string to match this ID and to return it.
  376.  
  377.  
  378.     2.8 Object types to generate IDCMP_IDCMPUPDATE events
  379.  
  380.     Certain objects convey extra information which is merged into the `fake'
  381.     input stream passed to the client calling LT_HandleInput(). These objects
  382.     are:
  383.  
  384.        STRING_KIND
  385.        TEXT_KIND
  386.        PALETTE_KIND
  387.  
  388.           The user pressed the `select' button which belongs
  389.           to this gadget. The MsgGadget pointer indicates the
  390.           STRING_KIND/TEXT_KIND/PALETTE_KIND object the `select'
  391.           button belongs to.
  392.  
  393.        LISTVIEW_KIND
  394.  
  395.           The user double-clicked on an entry. The entry number
  396.           is returned in the MsgCode variable. The MsgGadget
  397.           pointer indicates the LISTVIEW_KIND object the user
  398.           has clicked on.
  399.  
  400.  
  401.     2.9 Keystroke activation
  402.  
  403.     Unless forbidden via the the LA_NoKey tag item the user interface
  404.     code will pick the keyboard shortcuts for all gadgets on its own.
  405.     The currently active global console keymap will be checked at the
  406.     time when LT_Init() is called in order to make sure subsequent
  407.     calls to LT_Build() will use only keys the user can press on
  408.     the keyboard. Double-dead keys are also excluded from the
  409.     table created. This avoids problems with gadget labels such as
  410.     "éééé" which would require the user to hit two keys in a row to
  411.     activate the gadget.
  412.        If the window created happens to feature a close gadget
  413.     pressing the `Esc' key will cause the client to receive
  414.     an IDCMP_CLOSEWINDOW event.
  415.        A single LISTVIEW_KIND object may receive special treatment
  416.     if the LALV_CursorKey tag is used: the user will be able to
  417.     operate the listview using the cursor keys. Note: this
  418.     will also keep the user interface code from choosing a
  419.     special keystroke from the gadget label.
  420.        The user will be able to operate a single BUTTON_KIND
  421.     object using the return key if the LABT_ReturnKey tag is
  422.     used. A recessed frame will be drawn around the button hit
  423.     box to indicate its special status.
  424.        Pressing the Tab key can be bound to operate a cycle or
  425.     mx kind object.
  426.  
  427.     3. Credits
  428.  
  429.     The original design is based upon the user interface layout code used by
  430.     `term' 3.1. I put the first version of the layout routines together back
  431.     in Summer 1993 when I wanted to write the follow-up to `term' v3.4.
  432.  
  433.     Martin Taillefer rewrote large parts of the code, added new routines and
  434.     generally improved the performance of the layout process. I owe Martin
  435.     much for the ideas he put into the library.
  436.  
  437.     Kai Iske, Christoph Feck, Stefan Becker, Michael Barsoom and Sven Stullich
  438.     helped to iron out the remaining bugs and piled up bug reports and
  439.     enhancement requests.
  440.  
  441. gtlayout.library/--version--                     gtlayout.library/--version--
  442.  
  443.    NOTES
  444.     This document describes gtlayout.library v5.12 or higher. Do not assume that
  445.     previous library releases support the same features.
  446.  
  447. gtlayout.library/LT_Activate                     gtlayout.library/LT_Activate
  448.  
  449.    NAME
  450.     LT_Activate -- Activate a string type gadget.
  451.  
  452.    SYNOPSIS
  453.     LT_Activate(Handle,ID);
  454.                   A0   D0
  455.  
  456.     VOID LT_Activate(LayoutHandle *,LONG);
  457.  
  458.    FUNCTION
  459.     The equivalent to intuition.library/ActivateGadget().
  460.  
  461.    INPUTS
  462.     Handle - Pointer to LayoutHandle structure.
  463.  
  464.     ID - ID of Gadget to activate.
  465.  
  466.    RESULT
  467.     none
  468.  
  469.    SEE ALSO
  470.     intuition.library/ActivateGadget
  471.  
  472. gtlayout.library/LT_BeginRefresh             gtlayout.library/LT_BeginRefresh
  473.  
  474.    NAME
  475.     LT_BeginRefresh -- Optimized window refreshing
  476.  
  477.    SYNOPSIS
  478.     LT_BeginRefresh(Handle)
  479.                       A0
  480.  
  481.    FUNCTION
  482.     If you wish to handle window refreshing all on your own, you
  483.     might want to use the LT_BeginRefresh...LT_EndRefresh pair
  484.     in your program. By default the user interface layout engine
  485.     will automatically intercept IDCMP_REFRESHWINDOW events and
  486.     react to them accordingly.
  487.  
  488.    INPUTS
  489.     Handle - Pointer to a LayoutHandle structure.
  490.  
  491.    RESULT
  492.     none
  493.  
  494.    SEE ALSO
  495.     intuition.library/BeginRefresh
  496.     intuition.library/EndRefresh
  497.     gtlayout.library/LT_EndRefresh
  498.  
  499. gtlayout.library/LT_BuildA                         gtlayout.library/LT_BuildA
  500.  
  501.    NAME
  502.     LT_BuildA -- turn the user interface specs into a window
  503.                  and gadgets.
  504.  
  505.    SYNOPSIS
  506.     Window = LT_BuildA(Handle,Tags);
  507.       D0                 A0    A1
  508.  
  509.     struct Window *LT_BuildA(LayoutHandle *,struct TagItem *);
  510.  
  511.     Window = LT_Build(Handle,...);
  512.  
  513.     struct Window *LT_Build(LayoutHandle *,...);
  514.  
  515.    FUNCTION
  516.     This is the big one. After building up a user interface specification
  517.     using LT_NewA() a call to LT_BuildA() will finally lay out the single
  518.     user interface elements, open a window and put the gadgets, etc.
  519.     inside.
  520.  
  521.     The code tries to fit all the gadgets into the window, but if it
  522.     runs out of space it will fall back to a different font and
  523.     rescale the user interface objects to match it. It will first
  524.     fall back onto the system default font. If unsuccessful it will
  525.     as a last resort try to use topaz.font/8.
  526.  
  527.     To make it easier to distinguish between different handles that
  528.     share the same Window->UserPort, the Window->UserData pointer
  529.     will point to the LayoutHandle that created it (V13).
  530.  
  531.         NOTE: Earlier library releases did not support this feature,
  532.             so be prepared to deal with Window->UserData == NULL.
  533.  
  534.    INPUTS
  535.     Handle - Pointer to a LayoutHandle structure.
  536.  
  537.     Tags - Pointer to TagItem list controlling window
  538.         and layout attributes.
  539.  
  540.  
  541.     All the tag values given are passed straight away to OpenWindowTags(),
  542.     see intuition.doc for more information.
  543.  
  544.     In addition to this a number of private tag values are supported:
  545.  
  546.     LAWN_Menu (struct Menu *) - The menu to attach to the window, the
  547.         IDCMP flags will be updated to include IDCMP_MENUPICK if this
  548.         tag is used.
  549.  
  550.     LAWN_MenuTemplate (struct NewMenu *) - A list of filled-in
  551.         NewMenu structures which will get passed straight through
  552.         to LT_NewMenuTemplate(). If a menu could be created, it will
  553.         be attached to the window. LT_DeleteHandle() will then later
  554.         automatically dispose of the menu. Please note that the window
  555.         may fail to open due to the menu layout going wrong. Separate
  556.         calls to LT_NewMenuTemplate() and LT_Build() may be a better
  557.         approach since it is easier to find out which process went
  558.         wrong. You will find a pointer to the menu attached to the
  559.         LayoutHandle in LayoutHandle->Menu. Please note that this
  560.         entry only exists in LayoutHandles created by gtlayout.library
  561.         v13 or higher.
  562.  
  563.             NOTE: This tag effectively overrides LAWN_Menu.
  564.  
  565.         (requires gtlayout.library v13 or higher)
  566.  
  567.     LAWN_MenuTags (struct TagItem *) - A list of TagItems which
  568.         will get passed straight through to LT_NewMenuTagList().
  569.         Even if you don't ask for it, LT_Build() will pass
  570.         "LAMN_Handle,<Handle>" in for you, so any additional tags
  571.         specifying screen, fonts, etc. will be overridden. If a menu
  572.         could be created, it will be attached to the window.
  573.         LT_DeleteHandle() will then later automatically dispose of the
  574.         menu. Please note that the window may fail to open due to the
  575.         menu layout going wrong. Separate calls to LT_NewMenuTagList()
  576.         and LT_Build() may be a better approach since it is easier to
  577.         find out which process went wrong. You will find a pointer to the
  578.         menu attached to the LayoutHandle in LayoutHandle->Menu. Please note
  579.         that this entry only exists in LayoutHandles created by
  580.         gtlayout.library v13 or higher.
  581.  
  582.             NOTE: This tag effectively overrides LAWN_Menu and has
  583.                   precedence over LAWN_MenuTemplate.
  584.  
  585.         (requires gtlayout.library v13 or higher)
  586.  
  587.     LAWN_UserPort (struct MsgPort *) - The MsgPort to use as the
  588.         window user port. The MsgPort will be attached using the
  589.         common ModifyIDCMP() method, closing the window will
  590.         first remove and reply all pending messages at this port.
  591.  
  592.     LAWN_Left (LONG) - The left edge position the window is to use.
  593.         This effectively overrides any horizontal alignment flags.
  594.  
  595.             NOTE: the code may choose to ignore this value if it finds
  596.                 that the window will not fit onto the screen unless
  597.                 the left edge position is changed.
  598.  
  599.     LAWN_Top (LONG) - The top edge position the window is to use.
  600.         This effectively overrides any vertical alignment flags.
  601.  
  602.             NOTE: the code may choose to ignore this value if it finds
  603.                 that the window will not fit onto the screen unless
  604.                 the top edge position is changed.
  605.  
  606.     LAWN_Zoom (BOOL) - Adds a zoom gadget to the window. Clicking
  607.         on this gadget will cause the window to shrink/zoom back
  608.         to its original position. This differs from the WA_Zoom
  609.         tag behaviour. When the window zooms back to its original
  610.         position the gadgets are automatically refreshed.
  611.         Default: FALSE
  612.  
  613.     LAWN_MaxPen (LONG) - The maximum rendering pen index your code
  614.         will use. Since you are -- with some restrictions -- allowed
  615.         to render into the window created you may want to avoid
  616.         silly side effects if drawing images or other colourful
  617.         textures which do not share the common user interface colours.
  618.         By default the layout code will change the maximum rendering
  619.         pen number for the window to include only the user interface
  620.         pen colours. This can, but need not disturb your own private
  621.         window rendering.
  622.         Look up graphics.library/SetMaxPen for more information.
  623.         Default: determined by looking up Screen->DrawInfo.dri_Pens
  624.  
  625.     LAWN_BelowMouse (BOOL) - This instructs the layout routine to
  626.         centre the window created -- if possible -- below the
  627.         mouse pointer. This effectively ignores any left edge,
  628.         top edge or alignment settings.
  629.         Default: FALSE
  630.  
  631.     LAWN_MoveToWindow (BOOL) - When the window is finally open the
  632.         user interface code will try to make sure the entire window
  633.         is visible on the screen, this may involve moving the
  634.         currently visible portion of an autoscrolling screen.
  635.         Default: TRUE
  636.  
  637.     LAWN_AutoRefresh (BOOL) - Handle IDCMP_REFRESHWINDOW events
  638.         automatically.
  639.         Default: TRUE
  640.  
  641.     LAWN_HelpHook (struct Hook *) - Hook code to invoke when the user
  642.         presses the "Help" key. See gtlayout.h for more information.
  643.         Default: NULL
  644.  
  645.     LAWN_Parent (struct Window *) - Parent window to centre the child
  646.         window in.
  647.         Default: NULL
  648.  
  649.     LAWN_BlockParent (BOOL) - Lock the parent window via LT_LockWindow()
  650.         until the child window is closed.
  651.  
  652.             NOTE: requires LAWN_Parent attribute.
  653.  
  654.         Default: FALSE
  655.  
  656.     LAWN_SmartZoom (BOOL) - Attach a zoom gadget to the window created.
  657.         When in zoomed state, the window will be as small as possible,
  658.         showing only the window title and window gadgets:
  659.  
  660.             NOTE: this tag implies LAWN_Zoom,TRUE
  661.  
  662.         Default: FALSE
  663.  
  664.     LAWN_Title (STRPTR) - The window title to use. Use this tag in
  665.         place of WA_Title or you will break the layout code.
  666.         Default: no title
  667.  
  668.     LAWN_Bounds (struct IBox *) - Bounds to centre the window in.
  669.         Default: NULL
  670.  
  671.     LAWN_ExtraWidth (LONG) - Extra width to add into the calculation
  672.         when opening the window.
  673.         Default: 0
  674.  
  675.     LAWN_ExtraHeight (LONG) - Extra height to add into the calculation
  676.         when opening the window.
  677.         Default: 0
  678.  
  679.     LAWN_IDCMP (ULONG) - Use this tag in place of WA_IDCMP or you
  680.         will break the object handling code.
  681.  
  682.     LAWN_AlignWindow (UWORD) - Alignment information for the window, must
  683.         be a mask made from the following bit values:
  684.  
  685.             ALIGNF_RIGHT - Align to screen right edge
  686.             ALIGNF_LEFT - Align to screen left edge
  687.             ALIGNF_TOP - Align to screen top edge
  688.             ALIGNF_BOTTOM - Align to screen bottom edge
  689.  
  690.         Unless forbidden (such as by passing ALIGNF_RIGHT|ALIGNF_TOP)
  691.         the window will be centered horizontally and/or vertically.
  692.  
  693.     LAWN_FlushLeft (BOOL) - Add no horizontal space surrounding the
  694.         objects the windows will hold.
  695.         (requires gtlayout.library v10 or higher)
  696.  
  697.     LAWN_FlushTop (BOOL) - Add no vertical space surrounding the
  698.         objects the windows will hold.
  699.         (requires gtlayout.library v10 or higher)
  700.  
  701.     LAWN_Show (BOOL) - Make the window visible when it is opened;
  702.         this may involve depth-arranging screens.
  703.         (requires gtlayout.library v10 or higher)
  704.  
  705.     LAWN_NoInitialRefresh (BOOL) - If set to TRUE, adds the
  706.         gadgets, but does not draw the window imagery. You need
  707.         to draw them later by calling gtlayout.library/LT_Refresh.
  708.  
  709.    RESULT
  710.     Window - Pointer to a Window structure.
  711.  
  712.    SEE ALSO
  713.        gtlayout.library/LT_Refresh
  714.        intuition.library/OpenWindow
  715.        intuition.library/OpenWindowTagList
  716.  
  717. gtlayout.library/LT_CreateHandleTagListtlayout.library/LT_CreateHandleTagList
  718.  
  719.    NAME
  720.     LT_CreateHandleTagList -- Allocate auxilary data required by LT_New()
  721.                               and LT_BuildA().
  722.  
  723.    SYNOPSIS
  724.     Handle = LT_CreateHandleTagList(Screen,Tags);
  725.       D0                              A0    A1
  726.  
  727.     LayoutHandle *LT_CreateHandleTagList(struct Screen *,struct TagItem *);
  728.  
  729.     Handle = LT_CreateHandleTags(Screen,...);
  730.  
  731.     struct LayoutHandle *LT_CreateHandleTags(struct Screen *,...);
  732.  
  733.    FUNCTION
  734.     Memory is allocated, tables are set up and data is collected
  735.     on a screen a user interface is to be opened on. This
  736.     involves calculating the screen font parameters.
  737.  
  738.    INPUTS
  739.     Screen - Pointer to the screen the user interface is to
  740.         use. Passing NULL will cause the default public
  741.         screen to be used.
  742.  
  743.             NOTE: if NULL is passed the default public screen
  744.                 will stay locked until LT_DeleteHandle()
  745.                 is called.
  746.  
  747.     Tags - Tag values to control certain aspects of the
  748.         user interface created.
  749.  
  750.  
  751.     Valid tags include:
  752.  
  753.     LAHN_AutoActivate (BOOL) - Set to TRUE if you want the interface
  754.         to always keep a string gadget active if possible. Hitting
  755.         the return key will then cause the next following string
  756.         gadget to get activated, either cycling through all the
  757.         string gadgets available or stopping at the next string
  758.         gadget to have the LAST_LastGadget attribute set.
  759.         Default: TRUE
  760.  
  761.     LAHN_RawKeyFilter (BOOL) - Discard unprocessed IDCMP_RAWKEY
  762.         events.
  763.         Default: TRUE
  764.         (requires gtlayout.library v13 or higher)
  765.  
  766.     LAHN_UserData (APTR) - Store user specific data in the
  767.         LayoutHandle->UserData entry.
  768.  
  769.             NOTE: This tag requires gtlayout.library v9 and the
  770.                 corresponding entry in the LayoutHandle exists
  771.                 only under gtlayout.library v9 and up. *NEVER*
  772.                 write to this entry, use LT_SetAttributes()
  773.                 instead.
  774.  
  775.     LAHN_LocaleHook (struct Hook *) - The hook to call when
  776.         locale string IDs are to be mapped to strings. The
  777.         hook function is called with the following parameters:
  778.  
  779.         String = HookFunc(struct Hook *Hook,struct LayoutHandle *Handle,
  780.           D0                            A0                         A2
  781.                           LONG ID)
  782.                                A1
  783.  
  784.         The function is to look up the string associated with the ID
  785.         passed in and return the string.
  786.         Default: no locale hook
  787.  
  788.     LAHN_TextAttr (struct TTextAttr *) - The text font to use when
  789.         creating the gadgets and objects.
  790.         Default: Screen->Font
  791.  
  792.     LAHN_CloningPermitted (BOOL) - If a window will not fit onto the
  793.         screen the user interface is intended for, the layout engine
  794.         will scale the interface data down while stepping down in
  795.         font size. If all this fails, the engine will open a custom
  796.         screen for the window; this process is called "cloning".
  797.         The LAHN_CloningPermitted tag controls whether the engine will
  798.         actually try to open the custom screen or just return NULL
  799.         when LT_Build fails.
  800.         Default: TRUE
  801.  
  802.     LAHN_EditHook (struct Hook *) - You can specify a default string
  803.         gadget editing hook to be used for all following string
  804.         gadgets. Your hook should obey the same rules that apply
  805.         to hooks passed via GTST_EditHook/GTIN_EditHook.
  806.         Default: NULL
  807.  
  808.     LAHN_ExactClone (BOOL) - This tag works in conjunction with the
  809.         LAHN_CloningPermitted tag. By default the layout engine will
  810.         try to replicate only the basic characteristics of the
  811.         screen the window was intended to open on. This may result
  812.         in a screen which uses less colours than the original
  813.         screen. You can force the engine to make an almost exact
  814.         clone of the original screen by passing the LAHN_ExactClone
  815.         tag with a value of TRUE.
  816.         Default: FALSE
  817.  
  818.     LAHN_MenuGlyphs (BOOL) - This tag will make the layout engine
  819.         fill in the AmigaGlyph and CheckGlyph entries of the
  820.         LayoutHandle if running under Kickstart 3.0 or higher.
  821.         The corresponding images will be scaled to fit the actual
  822.         screen aspect ratio values and can later be used for
  823.         menu layout.
  824.         Default: FALSE
  825.  
  826.     LAHN_Parent (struct Window *) - You can pass a pointer to the
  827.         parent window of the window you intend to open using
  828.         the user interface layout engine. The new window will
  829.         open inside the boundaries of the parent window. If the
  830.         size does not fit, it will be opened centered over the
  831.         parent window.
  832.         Default: NULL
  833.  
  834.     LAHN_BlockParent (BOOL) - This tag works in conjunction with the
  835.         LAHN_Parent tag. If in effect, will block the parent window
  836.         via LT_LockWindow until the new window is closed, after
  837.         which the parent window is unlocked again.
  838.         Default: FALSE
  839.  
  840.     LAHN_SimpleClone (BOOL) - This tag works in conjunction with the
  841.         LAHN_CloningPermitted tag. It will make the layout engine
  842.         forget most information about the original screen the
  843.         user interface was intended for. In short, it will open a
  844.         simple default screen for the interface.
  845.         Default: FALSE
  846.  
  847.     LAHN_ExitFlush (BOOL) - When the LayoutHandle is finally disposed
  848.         of with LT_DeleteHandle() all variables maintained by the
  849.         input handling code will be flushed. For example, if you
  850.         would use the LA_STRPTR tag for STRING_KIND objects the
  851.         last string gadget contents would be copied into the buffer
  852.         pointed to by LA_STRPTR. If you do not want to use this
  853.         feature, disable it with "LAHN_ExitFlush,FALSE".
  854.         Default: TRUE
  855.         (requires gtlayout.library v9 or higher)
  856.  
  857.     LAHN_NoKeys (BOOL) - Use TRUE to tell the library not to pick
  858.         keyboard shortcuts all on its own. This works like calling
  859.         LT_New() for all objects with "LA_NoKey,TRUE,".
  860.         (requires gtlayout.library v26 or higher)
  861.  
  862.     LAHN_PubScreen (struct Screen *) - Pointer to public screen
  863.         window is to open on. Must be locked and open until you call
  864.         LT_Built().
  865.  
  866.     LAHN_PubScreenName (STRPTR) - Name of public screen to open window
  867.         on. The library will try to lock the named screen as soon as
  868.         you call LT_CreateHandle.
  869.  
  870.     LAHN_PubScreenFallBack (BOOL) - If the named public screen cannot
  871.         be found and you ask for it, the library will lock the default
  872.         public screen (default: TRUE).
  873.  
  874.    RESULT
  875.     Handle - Pointer to a LayoutHandle structure.
  876.  
  877. gtlayout.library/LT_DeleteHandle             gtlayout.library/LT_DeleteHandle
  878.  
  879.    NAME
  880.     LT_DeleteHandle -- Release storage space allocated by
  881.                        LT_CreateHandleTagList, closing windows,
  882.                        removing gadgets, etc.
  883.  
  884.    SYNOPSIS
  885.     LT_DeleteHandle(Handle);
  886.                       A0
  887.  
  888.     VOID LT_DeleteHandle(LayoutHandle *);
  889.  
  890.    FUNCTION
  891.     Windows and gadgets created by LT_CreateHandleTagList()
  892.     are removed, any associated memory is deallocated.
  893.  
  894.    INPUTS
  895.     Handle - Pointer to a LayoutHandle structure created
  896.         by LT_CreateHandleTaglist(). Passing NULL is
  897.         harmless.
  898.  
  899.    RESULT
  900.     none
  901.  
  902.    SEE ALSO
  903.     gtlayout.library/CreateHandleTagList
  904.  
  905. gtlayout.library/LT_DeleteWindowLock     gtlayout.library/LT_DeleteWindowLock
  906.  
  907.    NAME
  908.     LT_DeleteWindowLock -- Remove all locks from a window
  909.  
  910.    SYNOPSIS
  911.     LT_DeleteWindowLock(Window);
  912.                           A0
  913.  
  914.     VOID LT_DeleteWindowLock(struct Window *);
  915.  
  916.    FUNCTION
  917.     Before closing a locked window you should call this routine
  918.     which will remove all outstanding locks from it.
  919.  
  920.    INPUTS
  921.     Window - Pointer to window structure; passing NULL is
  922.     harmless.
  923.  
  924.    RESULT
  925.     none
  926.  
  927. gtlayout.library/LT_DisposeMenu               gtlayout.library/LT_DisposeMenu
  928.  
  929.    NAME
  930.     LT_DisposeMenu -- Release storage space allocated by
  931.                       LT_NewMenuTemplate or LT_NewMenuTagList (V11)
  932.  
  933.    SYNOPSIS
  934.     LT_DisposeMenu(Menu)
  935.                     A0
  936.  
  937.     VOID LT_DisposeMenu(struct Menu *);
  938.  
  939.    FUNCTION
  940.     Menus and MenuItems allocated by LT_NewMenuTemplate or
  941.     LT_NewMenuTagList are deallocated.
  942.  
  943.    INPUTS
  944.     Menu - Pointer to Menu structure as returned by
  945.         LT_NewMenuTemplate or LT_NewMenuTagList. Passing
  946.         NULL is harmless.
  947.  
  948.    RESULT
  949.     none
  950.  
  951.    SEE ALSO
  952.     gtlayout.library/LT_NewMenuTagList
  953.     gtlayout.library/LT_NewMenuTemplate
  954.  
  955. gtlayout.library/LT_EndGroup                     gtlayout.library/LT_EndGroup
  956.  
  957.    NAME
  958.     LT_EndGroup -- end a group declaration.
  959.  
  960.    SYNOPSIS
  961.     LT_EndGroup(Handle);
  962.                  A0
  963.  
  964.     VOID LT_EndGroup(LayoutHandle *);
  965.  
  966.    FUNCTION
  967.       This is just a short form of
  968.  
  969.            LT_New(Handle,
  970.                LA_Type, END_KIND,
  971.            TAG_DONE);
  972.  
  973.       It helps to save (some) space.
  974.  
  975.    INPUTS
  976.         Handle - Pointer to LayoutHandle.
  977.  
  978.    RESULT
  979.     none
  980.  
  981.    SEE ALSO
  982.     gtlayout.library/LT_New
  983.  
  984. gtlayout.library/LT_EndRefresh                 gtlayout.library/LT_EndRefresh
  985.  
  986.    NAME
  987.     LT_EndRefresh -- Optimized window refreshing
  988.  
  989.    SYNOPSIS
  990.     LT_EndRefresh(Handle)
  991.                     A0
  992.  
  993.     VOID LT_EndRefresh(LayoutHandle *);
  994.  
  995.    FUNCTION
  996.     If you wish to handle window refreshing all on your own, you
  997.     might want to use the LT_BeginRefresh...LT_EndRefresh pair
  998.     in your program. By default the user interface layout engine
  999.     will automatically intercept IDCMP_REFRESHWINDOW events and
  1000.     react to them accordingly.
  1001.  
  1002.    INPUTS
  1003.     Handle - Pointer to a LayoutHandle structure.
  1004.  
  1005.    RESULT
  1006.     none
  1007.  
  1008.    SEE ALSO
  1009.     gtlayout.library/LT_BeginRefresh
  1010.     intuition.library/BeginRefresh
  1011.     intuition.library/EndRefresh
  1012.  
  1013. gtlayout.library/LT_Exit                             gtlayout.library/LT_Exit
  1014.  
  1015.    NAME
  1016.     LT_Exit -- Clean up user interface allocations
  1017.  
  1018.    SYNOPSIS
  1019.     LT_Exit();
  1020.  
  1021.     VOID LT_Exit(VOID);
  1022.  
  1023.    FUNCTION
  1024.     When you are finished with user interface creation and
  1025.     do not not need the code any more you should call this
  1026.     routine. It will free all the memory allocated by
  1027.     LT_Init(), close libraries, etc.
  1028.  
  1029.    INPUTS
  1030.     none
  1031.  
  1032.    RESULT
  1033.     none
  1034.  
  1035.    NOTES
  1036.     This function is not present in the shared library, only
  1037.     in the link library. You need not and cannot invoke it in
  1038.     the shared library.
  1039.  
  1040.    SEE ALSO
  1041.     gtlayout.library/LT_Init
  1042.  
  1043. gtlayout.library/LT_FindMenuCommand       gtlayout.library/LT_FindMenuCommand
  1044.  
  1045.    NAME
  1046.     LT_FindMenuCommand -- Get the menu/submenu item associated
  1047.                           with a rawkey event (V11)
  1048.  
  1049.    SYNOPSIS
  1050.     Item = LT_FindMenuCommand(Menu,Code,Qualifier,Gadget)
  1051.      D0                        A0  D0       D0      A1
  1052.  
  1053.     struct MenuItem *LT_FindMenuCommand(struct Menu *,
  1054.  
  1055.                          UWORD,ULONG,struct Gadget *);
  1056.  
  1057.    FUNCTION
  1058.     With the IntuiMessage data copied from a type IDCMP_RAWKEY message
  1059.     tries to find the MenuItem the event referred to.
  1060.  
  1061.    INPUTS
  1062.     Menu - Pointer to Menu structure as returned by LT_NewMenuTagList.
  1063.  
  1064.     Code - Value copied from IntuiMessage->Code
  1065.  
  1066.     Qualifier - Value copied from IntuiMessage->Qualifier
  1067.  
  1068.     Gadget - Value copied from IntuiMessage->IAddress
  1069.  
  1070.    RESULT
  1071.     Item - Pointer to the struct MenuItem * in question or NULL
  1072.         if none could be found
  1073.  
  1074.    SEE ALSO
  1075.     gtlayout.library/LT_NewMenuTagList
  1076.  
  1077. gtlayout.library/LT_Fixed2String             gtlayout.library/LT_Fixed2String
  1078.  
  1079.    NAME
  1080.     LT_Fixed2String -- Convert a fixed-point number into an alphanumeric
  1081.                        string.
  1082.  
  1083.    SYNOPSIS
  1084.     LT_Fixed2String(Fixed,String);
  1085.                       D0    D1
  1086.  
  1087.     VOID LT_Fixed2String(FIXED,STRPTR);
  1088.  
  1089.    FUNCTION
  1090.     This routine implements a service similar to ftoa(). It converts
  1091.     a fixed point number into an ASCII representation.
  1092.  
  1093.    INPUTS
  1094.     Fixed - Fixed point numeric value
  1095.  
  1096.     String - Buffer to receive the converted value. This buffer
  1097.         must be at least 12 bytes large.
  1098.  
  1099.    NOTES
  1100.     The decimal point will be taken from the current locale.
  1101.     If locale.library is not installed in your system, the
  1102.     `.' character will be used instead.
  1103.  
  1104.     The arguments are passed in D0 and D1, this is *not* a
  1105.     typo.
  1106.  
  1107.    BUGS
  1108.     Works reliably, but the entire FIXED datatype operations
  1109.     are broken due to design faults.
  1110.  
  1111.    SEE ALSO
  1112.     gtlayout.library/LT_String2Fixed
  1113.  
  1114. gtlayout.library/LT_FixedMult                   gtlayout.library/LT_FixedMult
  1115.  
  1116.    NAME
  1117.     LT_FixedMult -- Multiply a fixed-point number with an integer value.
  1118.  
  1119.    SYNOPSIS
  1120.     Fixed = LT_FixedMult(Fixed,Factor)
  1121.       D0                   D0    D1
  1122.  
  1123.     FIXED LT_FixedMult(FIXED,ULONG);
  1124.  
  1125.    FUNCTION
  1126.     The layout engine provides only a fixed point multiplication
  1127.     routine. You need to implement other numeric operations on
  1128.     your own.
  1129.  
  1130.    INPUTS
  1131.     Fixed - Fixed-point number to be multiplied.
  1132.  
  1133.     Factor - Integer value to multiply fixed-point number with.
  1134.  
  1135.    RESULT
  1136.     Fixed - Product
  1137.  
  1138.    BUGS
  1139.     Works reliably, but the entire FIXED datatype operations
  1140.     are broken due to design faults.
  1141.  
  1142. gtlayout.library/LT_GetAttributesA         gtlayout.library/LT_GetAttributesA
  1143.  
  1144.    NAME
  1145.     LT_GetAttributesA -- Inquire information on a gadget.
  1146.  
  1147.    SYNOPSIS
  1148.     Value = LT_GetAttributesA(Handle,ID,Tags);
  1149.       D0                        A0   D0  A1
  1150.  
  1151.     LONG LT_GetAttributesA(LayoutHandle *,LONG ID,struct TagItem *);
  1152.  
  1153.     Value = LT_GetAttributes(Handle,ID,...);
  1154.  
  1155.     LONG LT_GetAttributes(LayoutHandle *,LONG ID,...);
  1156.  
  1157.    FUNCTION
  1158.     All objects created by the user interface layout code posess
  1159.     certain unique properties. The LT_GetAttributes() function will
  1160.     will inquire this information and return it. The implementation
  1161.     differs from gadtools.library/GT_GetGadgetAttrs in that you
  1162.     can inquire only a small subset of the object properties possible
  1163.     via the taglist passed in.
  1164.  
  1165.    INPUTS
  1166.     Handle - Pointer to LayoutHandle structure.
  1167.  
  1168.     ID - ID number of the object to inquire information about. This
  1169.         is the same value you passed via LA_ID to LT_New() when
  1170.         you created this object.
  1171.  
  1172.     Tags - TagItem list to receive information about the object
  1173.         in question.
  1174.  
  1175.  
  1176.     LA_Left (LONG *) - Left edge of object.
  1177.  
  1178.     LA_Top (LONG *) - Top edge of object.
  1179.  
  1180.     LA_Width (LONG *) - Width of object.
  1181.  
  1182.     LA_Height (LONG *) - Height of object.
  1183.  
  1184.     LA_Chars (LONG *) - Width of object measured in character
  1185.         widths.
  1186.         (requires gtlayout.library v9 or higher)
  1187.  
  1188.     LA_Lines (LONG *) - Height of object measured in character
  1189.         heights.
  1190.         (requires gtlayout.library v9 or higher)
  1191.  
  1192.     LA_LabelLeft (LONG *) - Left edge of label text.
  1193.         (requires gtlayout.library v9 or higher)
  1194.  
  1195.     LA_LabelTop (LONG *) - Top edge of label text.
  1196.         (requires gtlayout.library v9 or higher)
  1197.  
  1198.     LABO_Object (Object *) - Returns a pointer to the BOOPSI object
  1199.         the BOOPSI_KIND object is based upon.
  1200.  
  1201.             NOTE: Don't unlink the object or dispose of it or
  1202.                 terrible things are bound to happen.
  1203.  
  1204.         (requires gtlayout.library v10 or higher)
  1205.  
  1206.    RESULT
  1207.     The result depends on the object type:
  1208.  
  1209.         VERTICAL_KIND:
  1210.         HORIZONTAL_KIND:
  1211.  
  1212.             active page
  1213.  
  1214.         FRACTION_KIND:
  1215.  
  1216.             current LAFC_Number value
  1217.  
  1218.         SCROLLER_KIND:
  1219.  
  1220.             current GTSC_Top value
  1221.  
  1222.         TAPEDECK_KIND:
  1223.  
  1224.             current LATD_Pressed value
  1225.  
  1226.         LEVEL_KIND:
  1227.  
  1228.             current LAVL_Level state
  1229.  
  1230.         CHECKBOX_KIND:
  1231.  
  1232.             current GTCB_Checked state
  1233.  
  1234.         LISTVIEW_KIND:
  1235.  
  1236.             current GTLV_Selected state
  1237.  
  1238.         MX_KIND:
  1239.  
  1240.             current GTMX_Active state
  1241.  
  1242.         CYCLE_KIND:
  1243.  
  1244.             current GTCY_Active state
  1245.  
  1246.         POPUP_KIND:
  1247.  
  1248.             current LAPU_Active state
  1249.  
  1250.         TAB_KIND:
  1251.  
  1252.             current LATB_Active state
  1253.  
  1254.         PALETTE_KIND:
  1255.  
  1256.             current GTPA_Color state
  1257.  
  1258.         SLIDER_KIND:
  1259.  
  1260.             current GTSL_Level state
  1261.  
  1262.         GAUGE_KIND:
  1263.  
  1264.             current LAGA_Percent state
  1265.  
  1266.         STRING_KIND:
  1267.  
  1268.             pointer to current string
  1269.  
  1270.         PASSWORD_KIND:
  1271.  
  1272.             pointer to current string
  1273.  
  1274.         INTEGER_KIND:
  1275.  
  1276.             number currently entered
  1277.  
  1278.         BOOPSI_KIND:
  1279.  
  1280.             whatever the object thinks is its
  1281.             current value
  1282.  
  1283. gtlayout.library/LT_GetCode                       gtlayout.library/LT_GetCode
  1284.  
  1285.    NAME
  1286.     LT_GetCode -- Easy raw key event to ANSI conversion.
  1287.  
  1288.    SYNOPSIS
  1289.     Key = LT_GetCode(Qualifier,Class,Code,Gadget);
  1290.      D0                  D0     D1    D2    A0
  1291.  
  1292.     LONG LT_GetCode(ULONG,ULONG,UWORD,struct Gadget *);
  1293.  
  1294.    FUNCTION
  1295.     The user interface layout engine can convert IDCMP_RAWKEY
  1296.     events into ANSI codes. Pass in the data you copied from
  1297.     the IntuiMessage here.
  1298.  
  1299.    INPUTS
  1300.     Qualifier - Copied from IntuiMessage->Qualifier
  1301.  
  1302.     Class - Copied from IntuiMessage->Class
  1303.  
  1304.     Code - Copied from IntuiMessage->Code
  1305.  
  1306.     Gadget - Copied from IntuiMessage->IAddress
  1307.  
  1308.    RESULT
  1309.     Key - ANSI code generated from the input data
  1310.         or -1 if no such code was to be generated.
  1311.  
  1312. gtlayout.library/LT_GetIMsg                       gtlayout.library/LT_GetIMsg
  1313.  
  1314.    NAME
  1315.     LT_GetIMsg -- Retrieve the next pending IntuiMessage
  1316.                   from the window associated with a
  1317.                   LayoutHandle.
  1318.  
  1319.    SYNOPSIS
  1320.     IntuiMessage = LT_GetIMsg(Handle);
  1321.          D0                     A0
  1322.  
  1323.     struct IntuiMessage *LT_GetIMsg(LayoutHandle *);
  1324.  
  1325.    FUNCTION
  1326.     This routine will handle most of the input loop for
  1327.     you. Just pass the pointer to the layout handle in,
  1328.     check if the result code is non-null, copy the data
  1329.     you need and reply the message via LT_ReplyIMsg().
  1330.  
  1331.     You will still need to wait for new input, as LT_GetIMsg
  1332.     will poll the MsgPort of the window.
  1333.  
  1334.     LT_GetIMsg() will try its best to distinguish between
  1335.     different LayoutHandles sharing the same Window->UserPort.
  1336.     If it finds that the window the message was sent to is
  1337.     using a different LayoutHandle, it will switch to using
  1338.     this handle (V13).
  1339.  
  1340.    INPUTS
  1341.     Handle - Pointer to LayoutHandle structure
  1342.  
  1343.    RESULT
  1344.     IntuiMessage - Pointer to IntuiMessage structure
  1345.  
  1346.    NOTES
  1347.     You *must not* make any assumptions about the contents
  1348.     of the IntuiMessage structure except for the following
  1349.     entries:
  1350.  
  1351.        Class
  1352.        Code
  1353.        Qualifier
  1354.        IAddress
  1355.  
  1356.     When finished, you must dispose the IntuiMessage via
  1357.     LT_ReplyIMsg or memory will be lost which can never
  1358.     be reclaimed.
  1359.  
  1360.     DO NOT CALL LT_HandleInput() ON THE DATA YOU RECEIVE
  1361.     FROM LT_GetIMsg() AS LT_GetIMsg() ALREADY DOES ALL THE
  1362.     MAGIC LT_HandleInput() OTHERWISE WOULD NEED TO DO!
  1363.     IF YOU STILL DO CALL LT_HandleInput() ON THE DATA YOU
  1364.     WILL RECEIVE `GHOST' EVENTS.
  1365.  
  1366.    SEE ALSO
  1367.     gtlayout.library/LT_ReplyIMsg
  1368.  
  1369. gtlayout.library/LT_GetMenuItem               gtlayout.library/LT_GetMenuItem
  1370.  
  1371.    NAME
  1372.     LT_GetMenuItem -- Get the menu/submenu item associated with an ID (V11)
  1373.  
  1374.    SYNOPSIS
  1375.     Item = LT_GetMenuItem(Menu,ID)
  1376.      D0                    A0  D0
  1377.  
  1378.     struct MenuItem *LT_GetMenuItem(struct Menu *,ULONG);
  1379.  
  1380.    FUNCTION
  1381.     This routine scans through all menu items associated with the
  1382.     menu and returns a pointer to the item associated with the
  1383.     given ID value.
  1384.  
  1385.    INPUTS
  1386.     Menu - Pointer to Menu structure as returned by LT_NewMenuTagList.
  1387.  
  1388.     ID - Unique ID of the item to find.
  1389.  
  1390.    RESULT
  1391.     Item - Pointer to the struct MenuItem * in question or NULL
  1392.         if none could be found
  1393.  
  1394.    SEE ALSO
  1395.     gtlayout.library/LT_NewMenuTagList
  1396.  
  1397. gtlayout.library/LT_HandleInput               gtlayout.library/LT_HandleInput
  1398.  
  1399.    NAME
  1400.     LT_HandleInput -- Filter IntuiMessage data.
  1401.  
  1402.    SYNOPSIS
  1403.     LT_HandleInput(Handle,Qualifier,Class,Code,Gadget);
  1404.                      A0      A1      A2    A2    A3
  1405.  
  1406.     VOID LT_HandleInput(LayoutHandle *,ULONG,ULONG *,
  1407.                         UWORD *,struct Gadget **);
  1408.  
  1409.    FUNCTION
  1410.     In order to keep track of user interface actions, such as
  1411.     keys getting pressed, sliders getting moved, etc. your
  1412.     code is to call LT_HandleInput() with data copied from the
  1413.     IntuiMessage it has just received and replied.
  1414.  
  1415.    INPUTS
  1416.     Handle - Pointer to a LayoutHandle structure.
  1417.  
  1418.     Qualifier - The Qualifier value copied from the
  1419.         IntuiMessage structure.
  1420.  
  1421.     Class - Pointer to the ULONG variable which holds the
  1422.         value copied from the Class entry of the
  1423.         IntuiMessage structure.
  1424.  
  1425.     Code - Pointer to the UWORD variable which holds the
  1426.         value copied from the Code entry of the
  1427.         IntuiMessage structure.
  1428.  
  1429.     Gadget - Pointer to the Gadget value copied from the
  1430.         IAddress entry of the IntuiMessage structure.
  1431.  
  1432.    RESULT
  1433.     none
  1434.  
  1435.    EXAMPLE
  1436.     struct IntuiMessage *IntuiMessage;
  1437.     ULONG Qualifier,Class;
  1438.     UWORD Code;
  1439.     struct Gadget *Gadget;
  1440.  
  1441.     for(;;)
  1442.     {
  1443.         WaitPort(Window -> UserPort);
  1444.  
  1445.         while(IntuiMessage = GT_GetIMsg(Window -> UserPort))
  1446.         {
  1447.             Class = IntuiMessage -> Class;
  1448.             Code = IntuiMessage -> Code;
  1449.             Qualifier = IntuiMessage -> Qualifier;
  1450.             Gadget = IntuiMessage -> Gadget;
  1451.  
  1452.             GT_ReplyIMsg(IntuiMessage);
  1453.  
  1454.             LT_HandleInput(Handle,Qualifier,&Class,&Code,&Gadget);
  1455.         }
  1456.     }
  1457.  
  1458.    NOTES
  1459.     For BOOPSI_KIND objects keystroke activation may lead to
  1460.     unexpected results. Your application will hear a IDCMP_GADGETUP
  1461.     event, the IntuiMessage->Code value will hold the ANSI key
  1462.     code of the key the user pressed.
  1463.  
  1464.     Do not call this routine before you have actually
  1465.     replied the IntuiMessage received or weird things
  1466.     may happen. This is not a suggestion, it's a threat.
  1467.  
  1468. gtlayout.library/LT_Init                             gtlayout.library/LT_Init
  1469.  
  1470.    NAME
  1471.     LT_Init -- Initialize user interface code.
  1472.  
  1473.    SYNOPSIS
  1474.     LT_Init();
  1475.  
  1476.     VOID LT_Init(VOID);
  1477.  
  1478.    FUNCTION
  1479.     You need to initialize the user interface code only once,
  1480.     so it can set up its internals, open libraries, etc.
  1481.     The code has to be initialized before any user interface
  1482.     creation can take place.
  1483.  
  1484.    NOTES
  1485.     This function is not present in the shared library, only
  1486.     in the link library. You need not and cannot invoke it in
  1487.     the shared library.
  1488.  
  1489.    SEE ALSO
  1490.     gtlayout.library/LT_Exit
  1491.  
  1492. gtlayout.library/LT_LabelChars                 gtlayout.library/LT_LabelChars
  1493.  
  1494.    NAME
  1495.     LT_LabelChars -- Calculate the width of a a string
  1496.                      according to the user interface font
  1497.                      associated with a LayoutHandle.
  1498.  
  1499.    SYNOPSIS
  1500.     Length = LT_LabelChars(Handle,Label);
  1501.       D0                     A0    A1
  1502.  
  1503.     LONG LT_LabelChars(struct LayoutHandle *,STRPTR);
  1504.  
  1505.    FUNCTION
  1506.     Calculates the width of a string according to the user
  1507.     interface font used. The width is then converted to a number
  1508.     of characters suitable for using with the LA_Chars tag
  1509.     item when calling LT_New().
  1510.  
  1511.     You can pass multi-line label texts to this routine,
  1512.     it will calculate the maximum length of the single
  1513.     lines. (V12)
  1514.  
  1515.    INPUTS
  1516.     Handle - Pointer to LayoutHandle structure.
  1517.  
  1518.     Label - Pointer to string.
  1519.  
  1520.    RESULT
  1521.     Length - Number of characters that are considered
  1522.         equivalent to the string length in pixels.
  1523.  
  1524. gtlayout.library/LT_LabelWidth                 gtlayout.library/LT_LabelWidth
  1525.  
  1526.    NAME
  1527.     LT_LabelWidth -- Calculate the width of a string according
  1528.                      to the user interface font used.
  1529.  
  1530.    SYNOPSIS
  1531.     Width = LT_LabelWidth(Handle,Label);
  1532.       D0                    A0    A1
  1533.  
  1534.     LONG LT_LabelWidth(LayoutHandle *,STRPTR);
  1535.  
  1536.    FUNCTION
  1537.     This routine calculates the width of strings in
  1538.     terms of pixels according to the user interface
  1539.     font associated with the LayoutHandle.
  1540.  
  1541.     You can pass multi-line label texts to this routine,
  1542.     it will calculate the maximum length of the single
  1543.     lines. (V12)
  1544.  
  1545.    INPUTS
  1546.     Handle - Pointer to LayoutHandle structure.
  1547.  
  1548.    RESULT
  1549.     Width - Width of the text string in pixels.
  1550.  
  1551. gtlayout.library/LT_LayoutMenusA             gtlayout.library/LT_LayoutMenusA
  1552.  
  1553.    NAME
  1554.     LT_LayoutMenusA -- Create a menu according to a template.
  1555.  
  1556.    SYNOPSIS
  1557.     Menu = LT_LayoutMenusA(Handle,Template,Tags);
  1558.      D0                      A0     A1      A2
  1559.  
  1560.     struct Menu *LT_LayoutMenusA(LayoutHandle *,struct NewMenu *,
  1561.  
  1562.         struct TagItem *);
  1563.  
  1564.     Menu = LT_LayoutMenus(Handle,Template,...);
  1565.  
  1566.     struct Menu *LT_LayoutMenus(LayoutHandle *,struct NewMenu *,...);
  1567.  
  1568.    FUNCTION
  1569.     Unlike the corresponding routines in gadtools.library
  1570.     LT_LayoutMenusA() will both create and layout a menu.
  1571.     Also included is locale support.
  1572.  
  1573.    INPUTS
  1574.     Handle - Pointer to LayoutHandle structure.
  1575.  
  1576.     Template - Address of a ready-to-use NewMenu table to
  1577.         create the menu from.
  1578.  
  1579.     Tags - Tagitem list to control menu attributes
  1580.  
  1581.     Tags:
  1582.  
  1583.     LAMN_FirstLabel (LONG) - Locale ID of the first string to
  1584.         use as a menu title/item/subitem label. This tag
  1585.         works in conjunction with LA_LastLabel.
  1586.  
  1587.     LAMN_LastLabel (LONG) - Locale ID of the last string to
  1588.         use as a menu title/item/subitem label. This tag
  1589.         works in conjunction with LA_FirstLabel. The code
  1590.         will loop through FirstLabel..LastLabel and assign
  1591.         the corresponding locale text for each ID to the
  1592.         NewMenu.nm_Label entries. Labels which are already
  1593.         initialized with NM_BARLABEL are skipped.
  1594.  
  1595.     LAMN_LabelTable (LONG *) - Pointer to an array of IDs
  1596.         to use for building the menu labels. This requires
  1597.         that a locale hook is provided with the layout handle.
  1598.         The array is terminated by -1.
  1599.  
  1600.    RESULT
  1601.     Menu - Pointer to a Menu structure. You can free this
  1602.            using gadtools.library/FreeMenus().
  1603.  
  1604. gtlayout.library/LT_LevelWidth                 gtlayout.library/LT_LevelWidth
  1605.  
  1606.    NAME
  1607.     LT_LevelWidth -- Determine the maximum width of a SLIDER_KIND
  1608.                      level string.
  1609.  
  1610.    SYNOPSIS
  1611.     Index = LT_LevelWidth(Handle,FormatString,DispFunc,Min,Max,MaxWidth,
  1612.       D0                    A0        A1         A2     D0  D1    A3
  1613.  
  1614.                               MaxLen,FullCheck);
  1615.                                 A5      D2
  1616.  
  1617.     LONG LT_LevelWidth(LayoutHandle *,STRPTR,
  1618.                        LONG (*)(struct Gadget *,WORD),LONG,LONG,LONG *,
  1619.                        LONG *,BOOL);
  1620.  
  1621.    FUNCTION
  1622.     In order to make room for the level text displayed by a
  1623.     SLIDER_KIND object one needs to know how much space the
  1624.     longest level string will occupy. Otherwise, the level
  1625.     text may overwrite the gadget label text or the slider
  1626.     container. This routine will rattle through all possible
  1627.     slider settings (as given via the Min and the Max
  1628.     level values) and determine the longest label string
  1629.     according to the font used.
  1630.  
  1631.    INPUTS
  1632.     Handle - Pointer to a LayoutHandle structure, as returned by
  1633.         a call to LT_CreateHandleTags().
  1634.  
  1635.     FormatString - The sprintf() style formatting string to be used
  1636.         to format the slider level settings into text.
  1637.         This is the same string you would pass in via
  1638.         the GTSL_LevelFormat tag when creating the
  1639.         slider object.
  1640.         Default: "%lD" for systems which have locale.library
  1641.             installed, "%ld" otherwise.
  1642.  
  1643.     DispFunc - A pointer to the function to filter the slider level
  1644.         values. The result of this function will then be
  1645.         used to format a string into the slider level text.
  1646.         This is the same parameter you would pass in via
  1647.         the GTSL_DispFunc tag when creating the slider
  1648.         object.
  1649.  
  1650.             NOTE: the routine will be called with a NULL Gadget
  1651.                 parameter, make sure your code will handle
  1652.                 this nicely.
  1653.  
  1654.         Default: no display function
  1655.  
  1656.     Min - The smallest value the slider can be set to. This is
  1657.         same value you would pass in via GTSL_Min when creating
  1658.         the slider object.
  1659.  
  1660.     Max - The largest value the slider can be set to. This is
  1661.         same value you would pass in via GTSL_Max when creating
  1662.         the slider object.
  1663.  
  1664.     MaxWidth - Pointer to a place to store the width of the
  1665.         longest level string in pixels. If you pass
  1666.         in NULL instead of the address of a variable
  1667.         no harm will be done.
  1668.  
  1669.     MaxLen - Pointer to a place to store the length of the
  1670.         longest level string in characters. If you pass
  1671.         in NULL instead of the address of a variable
  1672.         no harm will be done.
  1673.  
  1674.     FullCheck - TRUE will cause the code to rattle through all
  1675.         possible slider settings, starting from the
  1676.         minimum value, ending at the maximum value.
  1677.         While this may be a good idea for a display
  1678.         function to map slider levels to text strings
  1679.         of varying length it might be a problem when
  1680.         it comes to display a range of numbers from
  1681.         1 to 40,000: the code will loop through
  1682.         40,000 iterations trying to find the longest
  1683.         string.
  1684.  
  1685.         FALSE will cause the code to calculate the
  1686.         longest level string based only on the
  1687.         minimum and the maximum value to check.
  1688.         While this is certainly a good a idea when
  1689.         it comes to display a range of numbers from
  1690.         1 to 40,000 as only two values will be
  1691.         checked the code may fail to produce
  1692.         accurate results for sliders using display
  1693.         functions mapping slider levels to strings.
  1694.  
  1695.    RESULT
  1696.     Index - The slider level which gives the longest
  1697.         level string.
  1698.  
  1699.    NOTES
  1700.     Some compilers have trouble passing parameters in A5. In such
  1701.     a case it is recommended to use gtlayout.library/LT_NewLevelWidth
  1702.     instead.
  1703.  
  1704.    SEE ALSO
  1705.     gtlayout.library/LT_NewLevelWidth
  1706.  
  1707. gtlayout.library/LT_LockWindow                 gtlayout.library/LT_LockWindow
  1708.  
  1709.    NAME
  1710.     LT_LockWindow -- Block user access to a window.
  1711.  
  1712.    SYNOPSIS
  1713.     LT_LockWindow(Window);
  1714.                     A0
  1715.  
  1716.     VOID LT_LockWindow(struct Window *);
  1717.  
  1718.    FUNCTION
  1719.     The window will get a wait mouse pointer attached and a blank
  1720.     Requester, preventing any user gadgets from getting used. The
  1721.     window minimum and maximum sizes are set to the current window
  1722.     size so the user will be unable to resize the window or click
  1723.     on the zoom gadget.
  1724.  
  1725.     This routine nests, multiple calls to LT_LockWindow() using the
  1726.     same window will increment a usage counter, so exactly the
  1727.     same number of calls to LT_UnlockWindow() will be required to
  1728.     unlock the window.
  1729.  
  1730.    INPUTS
  1731.     Window - Pointer to window structure; passign NULL is harmless.
  1732.  
  1733.    RESULT
  1734.     none
  1735.  
  1736.    NOTES
  1737.     Do not close the window you have locked unless all the
  1738.     outstanding locks are freed or memory will be lost which
  1739.     can never be reclaimed. Before you close the window,
  1740.     call gtlayout.library/LT_DeleteWindowLock.
  1741.  
  1742.    SEE ALSO
  1743.     gtlayout.library/LT_DeleteWindowLock
  1744.  
  1745. gtlayout.library/LT_MenuControlTagList gtlayout.library/LT_MenuControlTagList
  1746.  
  1747.    NAME
  1748.     LT_MenuControlTagList -- Manipulate menus, menu/submenu items (V11)
  1749.  
  1750.    SYNOPSIS
  1751.     LT_MenuControlTagList(Window,Menu,Tags)
  1752.                            A0   A1     A2
  1753.  
  1754.     VOID LT_MenuControlTagList(struct Window *,struct Menu *,struct TagItem *);
  1755.  
  1756.     VOID LT_MenuControlTags(struct Window *,struct Menu *,...);
  1757.  
  1758.    FUNCTION
  1759.     This routine provides a rather efficient way to set and to clear,
  1760.     to enable and to disable a number of menus, menu/submenu items
  1761.     all at once.
  1762.  
  1763.     In v18 this routine was modified to disconnect a menu strip
  1764.     from a window if it is about to change checkmark states. In
  1765.     earlier releases or if a single menu is attached to several
  1766.     windows it is recommended that you disconnect the menu from
  1767.     the windows it is attached to before you call this routine.
  1768.  
  1769.     As of v18 this routine is smart enough to handle menu
  1770.     mutual exclusion.
  1771.  
  1772.    INPUTS
  1773.     Window - Pointer to Window this menu is attached to. Starting with
  1774.              gtlayout.library v16 this parameter may be NULL.
  1775.  
  1776.     Menu - Pointer to Menu structure as returned by LT_NewMenuTagList.
  1777.  
  1778.     Tags - Pointer to a list of tagitem values, as found
  1779.            in gtlayout.h
  1780.  
  1781.  
  1782.     Tags:
  1783.  
  1784.     LAMN_ID (ULONG) - Unique ID of menu/menu item/submenu item to
  1785.         manipulate.
  1786.  
  1787.     LAMN_Checked (BOOL) - Set the checkmark state of the
  1788.         menu/submenu item.
  1789.  
  1790.     LAMN_Disabled (BOOL) - Set the availability state of the
  1791.         menu/menu item/submenu item.
  1792.  
  1793.     LAMN_FullMenuNum (UWORD) - Intuition menu number of
  1794.         menu/submenu item to manipulate. You would pass the
  1795.         result of the FULLMENUNUM() macro here for the
  1796.         item in question.
  1797.         (requires gtlayout.library v30 or higher)
  1798.  
  1799.    RESULT
  1800.     none
  1801.  
  1802.    EXAMPLE
  1803.     The following tagitem list will clear the checkmark and
  1804.     disable the menu item associated with ID 5 and set the
  1805.     checkmark for the item associated with ID 6:
  1806.  
  1807.         LAMN_ID,         5,
  1808.           LAMN_Checked,  FALSE,
  1809.           LAMN_Disabled, TRUE,
  1810.         LAMN_ID,         6,
  1811.           LAMN_Checked,  TRUE,
  1812.         TAG_DONE
  1813.  
  1814.    BUGS
  1815.     In library versions up to and including v17.2 this routine
  1816.     is broken. It won't do any harm, it just doesn't do what you
  1817.     want it to do.
  1818.  
  1819.    SEE ALSO
  1820.     gtlayout.library/LT_NewMenuTagList
  1821.  
  1822. gtlayout.library/LT_NewA                             gtlayout.library/LT_NewA
  1823.  
  1824.    NAME
  1825.     LT_NewA -- Add a new object to the user interface tree.
  1826.  
  1827.    SYNOPSIS
  1828.     LT_NewA(Handle,Tags);
  1829.              A0    A1
  1830.  
  1831.     VOID LT_NewA(LayoutHandle *,struct TagItem *);
  1832.  
  1833.     LT_New(Handle,...);
  1834.  
  1835.     VOID LT_New(LayoutHandle *,...);
  1836.  
  1837.    FUNCTION
  1838.     LT_NewA() is the routine you use to build the user interface,
  1839.     you give layout directions, design groups, etc. and finally
  1840.     call LT_BuildA() to turn these specifications into a window.
  1841.  
  1842.    INPUTS
  1843.     Handle - Pointer to LayoutHandle structure.
  1844.  
  1845.  
  1846.     This routine will accept almost all create-time tag items
  1847.     gadtools.library/CreateGadget will handle. In addition to
  1848.     this there are a bunch of extra gadget objects and extra
  1849.     tag items supported:
  1850.  
  1851.     All object types:
  1852.  
  1853.         LA_Type (LONG) - Type of the object to create, must be
  1854.             one of the following:
  1855.  
  1856.                 TEXT_KIND
  1857.                 VERTICAL_KIND
  1858.                 HORIZONTAL_KIND
  1859.                 END_KIND
  1860.                 FRAME_KIND
  1861.                 BOX_KIND
  1862.                 SLIDER_KIND
  1863.                 LISTVIEW_KIND
  1864.                 INTEGER_KIND
  1865.                 STRING_KIND
  1866.                 PASSWORD_KIND
  1867.                 PALETTE_KIND
  1868.                 BUTTON_KIND
  1869.                 CHECKBOX_KIND
  1870.                 NUMBER_KIND
  1871.                 GAUGE_KIND
  1872.                 CYCLE_KIND
  1873.                 POPUP_KIND
  1874.                 TAB_KIND
  1875.                 MX_KIND
  1876.                 XBAR_KIND
  1877.                 YBAR_KIND
  1878.                 FRACTION_KIND
  1879.                 TAPEDECK_KIND
  1880.                 LEVEL_KIND
  1881.                 BOOPSI_KIND
  1882.  
  1883.         LA_LabelText (STRPTR) - The object label text to use.
  1884.  
  1885.         LA_LabelID (LONG) - The locale text ID of the string to
  1886.             use as the object label text.
  1887.  
  1888.                 NOTE: LT_NewA() will fail if you forget
  1889.                     to select a hook with LAHN_LocaleHook
  1890.                     at LT_CreateHandleTagList.
  1891.  
  1892.         LA_ID (LONG) - The gadget ID to use for this object.
  1893.  
  1894.                 NOTE: User ID values *MUST* be greater than 0,
  1895.                       negative values are reserved for internal
  1896.                       use.
  1897.  
  1898.         LA_Chars (LONG) - The width of this object measured in
  1899.             characters. If each character of the user interface
  1900.             font is 8 pixels wide an object with LA_Chars set to
  1901.             10 will usually be 80 pixels wide.
  1902.  
  1903.         LA_LabelChars (LONG) - This forces the internal gadget
  1904.             label width the layout engine calculates during the
  1905.             layout pass to a specific value. Note: this does
  1906.             not work well with all objects.
  1907.  
  1908.             (requires gtlayout.library v9 or higher)
  1909.  
  1910.         LA_LabelPlace (LONG) - Where to place the gadget label.
  1911.             Not all objects will support all label positions:
  1912.  
  1913.                 PLACE_LEFT - Place label text left of object
  1914.                 PLACE_RIGHT - Place label text right of object
  1915.                 PLACE_ABOVE - Place label text above object
  1916.                 PLACE_IN - Place label text in object
  1917.                 PLACE_BELOW - Place label text below object
  1918.  
  1919.         LA_ExtraSpace (BOOL) - Add extra vertical/horizontal
  1920.             space before this object.
  1921.             Default: FALSE
  1922.  
  1923.         LA_ExtraFat (BOOL) - Make this object a bit larger
  1924.             than its usual size.
  1925.             Default: FALSE
  1926.  
  1927.         LA_NoKey (BOOL) - Don't let the user interface choose
  1928.             a keyboard shortcut for this object.
  1929.             Default: FALSE
  1930.  
  1931.         LA_HighLabel (BOOL) - Use highlight pen when rendering
  1932.             the gadget label text.
  1933.             Default: FALSE
  1934.  
  1935.         LA_BYTE (BYTE *) - Pointer to the variable that holds
  1936.             the "current value" of the object. The layout engine
  1937.             will retrieve this value initially during the creation
  1938.             of the object and maintain it during its lifespan.
  1939.             This means you do not need to worry about checking
  1940.             the state of the object, the user interface layout
  1941.             engine will do it for you.
  1942.  
  1943.         LA_UBYTE (UBYTE *) - Pointer to the variable that holds
  1944.             the "current value" of the object. The layout engine
  1945.             will retrieve this value initially during the creation
  1946.             of the object and maintain it during its lifespan.
  1947.             This means you do not need to worry about checking
  1948.             the state of the object, the user interface layout
  1949.             engine will do it for you.
  1950.  
  1951.         LA_WORD (WORD *) - Pointer to the variable that holds
  1952.             the "current value" of the object. The layout engine
  1953.             will retrieve this value initially during the creation
  1954.             of the object and maintain it during its lifespan.
  1955.             This means you do not need to worry about checking
  1956.             the state of the object, the user interface layout
  1957.             engine will do it for you.
  1958.  
  1959.         LA_UWORD (UWORD *) - Pointer to the variable that holds
  1960.             the "current value" of the object. The layout engine
  1961.             will retrieve this value initially during the creation
  1962.             of the object and maintain it during its lifespan.
  1963.             This means you do not need to worry about checking
  1964.             the state of the object, the user interface layout
  1965.             engine will do it for you.
  1966.  
  1967.         LA_BOOL (BOOL *) - Pointer to the variable that holds
  1968.             the "current value" of the object. The layout engine
  1969.             will retrieve this value initially during the creation
  1970.             of the object and maintain it during its lifespan.
  1971.             This means you do not need to worry about checking
  1972.             the state of the object, the user interface layout
  1973.             engine will do it for you.
  1974.  
  1975.         LA_LONG (LONG *) - Pointer to the variable that holds
  1976.             the "current value" of the object. The layout engine
  1977.             will retrieve this value initially during the creation
  1978.             of the object and maintain it during its lifespan.
  1979.             This means you do not need to worry about checking
  1980.             the state of the object, the user interface layout
  1981.             engine will do it for you.
  1982.  
  1983.         LA_ULONG (ULONG *) - Pointer to the variable that holds
  1984.             the "current value" of the object. The layout engine
  1985.             will retrieve this value initially during the creation
  1986.             of the object and maintain it during its lifespan.
  1987.             This means you do not need to worry about checking
  1988.             the state of the object, the user interface layout
  1989.             engine will do it for you.
  1990.  
  1991.         LA_STRPTR (STRPTR) - Pointer to the variable that holds
  1992.             the "current value" of the object. The layout engine
  1993.             will retrieve this value initially during the creation
  1994.             of the object and maintain it during its lifespan.
  1995.             This means you do not need to worry about checking
  1996.             the state of the object, the user interface layout
  1997.             engine will do it for you.
  1998.  
  1999.         LA_FRACTION (FRACTION *) - Pointer to the variable that holds
  2000.             the "current value" of the object. The layout engine
  2001.             will retrieve this value initially during the creation
  2002.             of the object and maintain it during its lifespan.
  2003.             This means you do not need to worry about checking
  2004.             the state of the object, the user interface layout
  2005.             engine will do it for you.
  2006.  
  2007.  
  2008.         TEXT_KIND:
  2009.  
  2010.             LATX_Picker (BOOL) - Attach a `select' button to the
  2011.                 right hand side of the text display.
  2012.                 Default: FALSE
  2013.  
  2014.             LATX_LockSize (BOOL) - After doing the initial layout
  2015.                 for this object, do not adapt its size again during
  2016.                 subsequent layouts. This is particularly useful if
  2017.                 you have a TEXT_KIND object in a paged group
  2018.                 and update its contents later. You need
  2019.                 to specify an object width using LA_Chars, otherwise
  2020.                 the layout engine may make it not wide enough to
  2021.                 display any text.
  2022.                 (requires gtlayout.library v15 or higher)
  2023.  
  2024.  
  2025.         VERTICAL_KIND (group to align objects vertically):
  2026.         HORIZONTAL_KIND (group to align objects horizontally):
  2027.  
  2028.             LAGR_Spread (BOOL) - Place all objects in this
  2029.                 group with roughly the same amount of space
  2030.                 between them.
  2031.                 Default: FALSE
  2032.  
  2033.             LAGR_SameSize (BOOL) - Make all objects in this
  2034.                 group the same size (for vertical groups:
  2035.                 the same height, for horizontal groups:
  2036.                 the same width).
  2037.                 Default: FALSE
  2038.  
  2039.             LAGR_LastAttributes (BOOL) - Try to copy the
  2040.                 size of the previous group for this new
  2041.                 group. May not work if this group turns
  2042.                 out to be larger than the previous group.
  2043.                 Default: FALSE
  2044.  
  2045.             LAGR_ActivePage (LONG) - Organize all child
  2046.                 groups as pages which can be flipped through
  2047.                 using LT_SetAttributes(). You need to
  2048.                 specify the number of the first page to
  2049.                 display, starting from 0.
  2050.  
  2051.                     NOTE: Specifying this tag actually enables
  2052.                         the paging feature. If you omit this
  2053.                         tag calls to flip to a specific
  2054.                         page will fail.
  2055.  
  2056.                 Default: No paging
  2057.  
  2058.             LAGR_Frame (BOOL) - Draw a recessed frame around
  2059.                 this group, even if there is no group label.
  2060.                 (requires gtlayout.library v7 or higher)
  2061.  
  2062.             LAGR_IndentX (BOOL) - Add extra horizontal indentation
  2063.                 for this group.
  2064.                 (requires gtlayout.library v10 or higher)
  2065.  
  2066.             LAGR_IndentY (BOOL) - Add extra vertical indentation
  2067.                 for this group.
  2068.                 (requires gtlayout.library v10 or higher)
  2069.  
  2070.             LAGR_NoIndent (BOOL) - Inhibit automatic size adjustion
  2071.                 and centring of this group if it is smaller than
  2072.                 the neighbouring groups.
  2073.                 (requires gtlayout.library v21 or higher)
  2074.  
  2075.             LAGR_SameWidth (WORD) - During the final layout pass,
  2076.                 make this group the same width as the group which
  2077.                 uses the given ID. Not implemented yet.
  2078.                 (requires gtlayout.library v25 or higher)
  2079.  
  2080.             LAGR_SameHeight (WORD) - During the final layout pass,
  2081.                 make this group the same height as the group which
  2082.                 uses the given ID. Not implemented yet.
  2083.                 (requires gtlayout.library v25 or higher)
  2084.  
  2085.  
  2086.         FRAME_KIND (fixed size general purpose display,
  2087.             you may render into it):
  2088.  
  2089.             LAFR_InnerWidth (LONG) - Inner width of the
  2090.                 display box.
  2091.  
  2092.             LAFR_InnerHeight (LONG) - Inner height of the
  2093.                 display box.
  2094.  
  2095.             LAFR_DrawBox (BOOL) - Draw a recessed bevel box
  2096.                 around the display box.
  2097.                 Default: FALSE
  2098.  
  2099.             LAFR_RefreshHook (struct Hook *) - Hook to call
  2100.                 when refreshing/redrawing this object. See
  2101.                 gtlayout.h for more information.
  2102.                 (requires gtlayout.library v9 or higher)
  2103.  
  2104.             LAFR_GenerateEvents (BOOL) - If TRUE, clicking
  2105.                 inside the FRAME_KIND object will generate
  2106.                 IDCMP_GADGETUP/IDCMP_GADGETDOWN events. If
  2107.                 you wish to know where the click occured,
  2108.                 make a copy of the Window->MouseX/Y entries
  2109.                 before you call LT_HandleInput()/LT_GetIMsg().
  2110.                 Default: FALSE
  2111.                 (requires gtlayout.library v28 or higher)
  2112.  
  2113.  
  2114.         XBAR_KIND (horizontal separator bar):
  2115.  
  2116.             LAXB_FullSize (BOOL) - Make this separator bar span
  2117.                 the entire window width.
  2118.  
  2119.  
  2120.         BOX_KIND (multiline text display):
  2121.  
  2122.             LABX_Labels (STRPTR *) - The label texts to display
  2123.                 on the right hand side of the box. Terminate
  2124.                 this array with NULL.
  2125.  
  2126.             LABX_Lines (STRPTR *) - The text to display in the
  2127.                 box. Terminate this array with NULL.
  2128.  
  2129.             LABX_Rows (LONG) - The width of this object in
  2130.                 characters. The layout routine will try to make
  2131.                 sure that the given number of characters will
  2132.                 fit into a single line of text in this box.
  2133.                 This may be a problem with proportional spaced
  2134.                 fonts.
  2135.  
  2136.             LABX_AlignText (LONG) - Controls how text is aligned
  2137.                 in box lines:
  2138.  
  2139.                     ALIGNTEXT_LEFT - Align text to the left edge
  2140.                     ALIGNTEXT_CENTERED - Centre the text
  2141.                     ALIGNTEXT_RIGHT - Align text to the right edge
  2142.                     ALIGNTEXT_PAD - Pad text lines
  2143.  
  2144.                 Default: ALIGNTEXT_LEFT
  2145.  
  2146.             LABX_DrawBox (BOOL) - Draw a recessed bevel box
  2147.                 around the text box.
  2148.                 Default: FALSE
  2149.  
  2150.             LABX_FirstLabel (LONG) - Locale string ID of the first
  2151.                 text to use as a box label. Works in conjunction
  2152.                 with LABX_LastLabel.
  2153.  
  2154.             LABX_LastLabel (LONG) - Locale string ID of the last
  2155.                 text to use as a box label. Works in conjunction
  2156.                 with LABX_FirstLabel. When building the interface the
  2157.                 code will loop from FirstLabel..LastLabel, look
  2158.                 up the corresponding locale strings and use the
  2159.                 data to make up the label text to appear at the
  2160.                 right hand side of the box.
  2161.  
  2162.             LABX_LabelTable (LONG *) - Pointer to an array of IDs
  2163.                 to use for building the box labels. This requires
  2164.                 that a locale hook is provided with the layout handle.
  2165.                 The array is terminated by -1.
  2166.  
  2167.             LABX_ReserveSpace (BOOL) - Allocate extra memory to hold
  2168.                 the contents of the lines displayed. This avoids nasty
  2169.                 side-effects when refreshing this object.
  2170.                 Default: FALSE
  2171.  
  2172.             LABX_FirstLine (LONG) - Locale string ID of the first
  2173.                 text to print inside the box. Works in conjunction
  2174.                 with LABX_LastLine.
  2175.                 (requires gtlayout.library v26 or higher)
  2176.  
  2177.             LABX_LastLine (LONG) - Locale string ID of the last
  2178.                 text to print inside the box. Works in conjunction
  2179.                 with LABX_FirstLine.
  2180.                 (requires gtlayout.library v26 or higher)
  2181.  
  2182.             LABX_LineTable (LONG *) - Pointer to an array of IDs
  2183.                 to use for building the box contents lines. This requires
  2184.                 that a locale hook is provided with the layout handle.
  2185.                 The array is terminated by -1.
  2186.                 (requires gtlayout.library v28 or higher)
  2187.  
  2188.             LABX_Line (STRPTR) - Line to display in the box, may
  2189.                 contain '\n' line break characters, the layout engine
  2190.                 will chop the single line into single consecutive lines
  2191.                 following the '\n' chars.
  2192.                 (requires gtlayout.library v31 or higher)
  2193.  
  2194.             LABX_LineID (LONG) - Locale ID of line text to display in the
  2195.                 box, may contain '\n' line break characters, the layout
  2196.                 engine will chop the single line into single consecutive lines
  2197.                 following the '\n' chars.
  2198.                 (requires gtlayout.library v31 or higher)
  2199.  
  2200.         FRACTION_KIND:
  2201.  
  2202.             LAFC_MaxChars (LONG) - Maximum number of characters to
  2203.                 fit into the entry field.
  2204.                 Default: 16
  2205.  
  2206.             LAFC_Number (FIXED) - Fixed point number to use for
  2207.                 this object.
  2208.                 Default: 0.0
  2209.  
  2210.             LAFC_LastGadget (BOOL) - When cycling through the
  2211.                 text entry fields, stop cycling after leaving
  2212.                 this object.
  2213.                 Default: FALSE
  2214.  
  2215.             LAFC_Min (FIXED) - Minimum value allowed for this
  2216.                 object.
  2217.  
  2218.             LAFC_Max (FIXED) - Maximum value allowed for this
  2219.                 object.
  2220.  
  2221.             LAFC_HistoryLines (LONG) - Maximum number of entries
  2222.                 to keep as a backlog.
  2223.                 Default: 0
  2224.  
  2225.             LAFC_HistoryHook (struct Hook *) - Hook code to call
  2226.                 when entering a number into the backlog. See
  2227.                 gtlayout.h for more information.
  2228.                 Default: NULL
  2229.  
  2230.             LAFC_Activate (BOOL) - When the window opens, make this
  2231.                 gadget the active one.
  2232.  
  2233.                     NOTE: There can be only one gadget of this type
  2234.                         per window.
  2235.  
  2236.                 Default: FALSE
  2237.                 (requires gtlayout.library v21 or higher)
  2238.  
  2239.  
  2240.         SLIDER_KIND:
  2241.  
  2242.             LASL_FullCheck: TRUE will cause the code to rattle
  2243.                 through all possible slider settings, starting
  2244.                 from the minimum value, ending at the maximum value.
  2245.                 While this may be a good idea for a display
  2246.                 function to map slider levels to text strings
  2247.                 of varying length it might be a problem when
  2248.                 it comes to display a range of numbers from
  2249.                 1 to 40,000: the code will loop through
  2250.                 40,000 iterations trying to find the longest
  2251.                 string.
  2252.  
  2253.                 FALSE will cause the code to calculate the
  2254.                 longest level string based only on the
  2255.                 minimum and the maximum value to check.
  2256.                 While this is certainly a good a idea when
  2257.                 it comes to display a range of numbers from
  2258.                 1 to 40,000 as only two values will be
  2259.                 checked the code may fail to produce
  2260.                 accurate results for sliders using display
  2261.                 functions mapping slider levels to strings.
  2262.  
  2263.                 Default: TRUE
  2264.  
  2265.  
  2266.         LEVEL_KIND:
  2267.  
  2268.             All tags are supported which SLIDER_KIND supports.
  2269.             The gadget level display however, can only be aligned
  2270.             to the left border.
  2271.  
  2272.  
  2273.         LISTVIEW_KIND:
  2274.  
  2275.             LALV_ExtraLabels (STRPTR *) - Place extra line
  2276.                 labels at the right of the box. Terminate
  2277.                 this array with NULL.
  2278.  
  2279.             LALV_Labels (STRPTR *) - The labels to display
  2280.                 inside the box, you can pass this array of
  2281.                 strings in rather than passing an initialized
  2282.                 List of text via GTLV_Labels. Terminate
  2283.                 this array with NULL.
  2284.  
  2285.             LALV_CursorKey (BOOL) - Let the user operate this
  2286.                 listview using the cursor keys.
  2287.  
  2288.                     NOTE: there can be only one single listview
  2289.                         per window to sport this feature.
  2290.  
  2291.                 Default: FALSE
  2292.  
  2293.             LALV_Lines (LONG) - The number of text lines this
  2294.                 listview is to display.
  2295.  
  2296.             LALV_Link (LONG) - The Gadget ID of a string gadget
  2297.                 to attach to this listview.
  2298.  
  2299.                     NOTE: you need to
  2300.                         add the Gadget in question before you add the
  2301.                         listview to refer to it or the layout routine
  2302.                         will get confused.
  2303.  
  2304.                 Passing the value NIL_LINK will create a listview
  2305.                 which displays the currently selected item, otherwise
  2306.                 you will get a read-only list.
  2307.  
  2308.             LALV_FirstLabel (LONG) - Locale string ID of the first
  2309.                 text to use as a list label. Works in conjunction
  2310.                 with LALV_LastLabel.
  2311.  
  2312.             LALV_LastLabel (LONG) - Locale string ID of the last
  2313.                 text to use as a list label. Works in conjunction
  2314.                 with LALV_FirstLabel. When building the interface the
  2315.                 code will loop from FirstLabel..LastLabel, look
  2316.                 up the corresponding locale strings and use the
  2317.                 data to make up the label text to appear in the
  2318.                 list.
  2319.  
  2320.             LALV_LabelTable (LONG *) - Pointer to an array of IDs
  2321.                 to use for building the listview contents. This requires
  2322.                 that a locale hook is provided with the layout handle.
  2323.                 The array is terminated by -1.
  2324.  
  2325.             LALV_MaxGrowX (LONG) - Maximum width of this object
  2326.                 measured in characters. When the first layout pass
  2327.                 is finished and there is still enough space left
  2328.                 to make the listview wider, the width is increased
  2329.                 until it hits the limit specified using this tag.
  2330.  
  2331.                     NOTE: there can be only one single listview
  2332.                         per window to sport this feature.
  2333.  
  2334.                 Default: 0
  2335.  
  2336.             LALV_MaxGrowY (LONG) - Maximum height of this object
  2337.                 measured in lines. When the first layout pass is
  2338.                 finished and there is still enough space left to
  2339.                 make the listview higher, the height is increased
  2340.                 until it hits the limit specified using this tag.
  2341.  
  2342.                     NOTE: there can be only one single listview
  2343.                         per window to sport this feature.
  2344.  
  2345.                 Default: 0
  2346.  
  2347.             LALV_ResizeX (BOOL) - Makes this listview resizable
  2348.                 in the horizontal direction, attaches a sizing
  2349.                 gadget to the window to open and handles window
  2350.                 resize operations automatically.
  2351.                 (requires gtlayout.library v9 or higher)
  2352.  
  2353.                     NOTE: there can be only one single listview
  2354.                         per window to sport this feature.
  2355.  
  2356.                         Also listen to IDCMP_CLOSEWINDOW events
  2357.                         which may be generated if the layout
  2358.                         engine runs out of memory when rebuilding
  2359.                         the user interface.
  2360.  
  2361.                 Default: FALSE
  2362.  
  2363.             LALV_ResizeY (BOOL) - Makes this listview resizable
  2364.                 in the vertical direction, attaches a sizing
  2365.                 gadget to the window to open and handles window
  2366.                 resize operations automatically.
  2367.                 (requires gtlayout.library v9 or higher)
  2368.  
  2369.                     NOTE: there can be only one single listview
  2370.                         per window to sport this feature.
  2371.  
  2372.                         Also listen to IDCMP_CLOSEWINDOW events
  2373.                         which may be generated if the layout
  2374.                         engine runs out of memory when rebuilding
  2375.                         the user interface.
  2376.  
  2377.                 Default: FALSE
  2378.  
  2379.             LALV_MinChars (WORD) - Minimum width for this
  2380.                 object, measured in characters. Used in
  2381.                 conjunction with LALV_ResizeX.
  2382.                 (requires gtlayout.library v9 or higher)
  2383.  
  2384.             LALV_MinLines (WORD) - Minimum height for this
  2385.                 object, measured in lines. Used in
  2386.                 conjunction with LALV_ResizeY.
  2387.                 (requires gtlayout.library v9 or higher)
  2388.  
  2389.             LALV_LockSize (BOOL) - After doing the initial layout
  2390.                 for this object, do not adapt its size again during
  2391.                 subsequent layouts. This is particularly useful if
  2392.                 you have a LISTVIEW_KIND object in a paged group
  2393.                 and keep adding new entries to the list. You need
  2394.                 to specify an object width using LA_Chars, otherwise
  2395.                 the layout engine may make it not wide enough to
  2396.                 display any entries.
  2397.                 (requires gtlayout.library v8 or higher)
  2398.  
  2399.             LALV_FlushLabelLeft (BOOL) - For a gadget label placed
  2400.                 above the listview align the text to the left edge
  2401.                 of the view.
  2402.                 (requires gtlayout.library v9 or higher)
  2403.  
  2404.             LALV_TextAttr (struct TextAttr *) - You can specify a
  2405.                 fixed-width font to be used for the list display.
  2406.                 The TextAttr (or TTextAttr) you provide must be ready
  2407.                 to go so the layout code can open the font later.
  2408.  
  2409.                 To get the current system default font, which is
  2410.                 guaranteed to be fixed-width, pass ~0 instead of a
  2411.                 pointer to a TextAttr structure.
  2412.  
  2413.                     NOTE: The font *MUST* be fixed-width or the layout
  2414.                         will fail.
  2415.  
  2416.                          Choose your font in such a way that it matches
  2417.                          in width and height with the other probably
  2418.                          proportional-spaced user interface font.
  2419.  
  2420.                          If the layout engine decides to step down in
  2421.                          font size, all LISTVIEW_KIND objects which were
  2422.                          configured to use a special fixed-width font
  2423.                          will `forget' about it. This won't matter much
  2424.                          as the fonts the engine chooses will always be
  2425.                          fixed-width anyway.
  2426.  
  2427.                 (requires gtlayout.library v10 or higher)
  2428.  
  2429.             LALV_AutoPageID (LONG) - ID of paged GROUP_KIND object
  2430.                 which will be set to the gadget's current setting.
  2431.                 (requires gtlayout.library v23 or higher)
  2432.  
  2433.                     NOTE: Listen to IDCMP_CLOSEWINDOW events
  2434.                         which may be generated if the layout
  2435.                         engine runs out of memory when rebuilding
  2436.                         the user interface.
  2437.  
  2438.  
  2439.         INTEGER_KIND:
  2440.  
  2441.             LAIN_LastGadget (BOOL) - Pressing return with this
  2442.                 gadget active will stop activating the next
  2443.                 following string gadget type if TRUE is passed.
  2444.                 Default: FALSE
  2445.  
  2446.             LAIN_Min (LONG) - Minimum accepted numeric value.
  2447.                 Default: -2147483647
  2448.  
  2449.             LAIN_Max (LONG) - Maximum accepted numeric value.
  2450.                 Default:  2147483647
  2451.  
  2452.             LAIN_UseIncrementers (BOOL) - Use TRUE to add incrementer
  2453.                 arrow buttons to the right of the numeric entry field.
  2454.                 These buttons will let you cycle through a set of
  2455.                 numbers to be displayed in the numeric entry field.
  2456.                 Default: FALSE
  2457.  
  2458.             LAIN_HistoryLines (LONG) - Number of numbers entered to
  2459.                 keep as a backlog.
  2460.                 Default: 0
  2461.  
  2462.             LAIN_HistoryHook (struct Hook *) - Hook code to call when
  2463.                 entering a number into the backlog. See gtlayout.h for
  2464.                 more information.
  2465.                 Default: NULL
  2466.  
  2467.             LAIN_IncrementerHook (struct Hook *) - Hook code to call
  2468.                 when cycling through numeric values. See gtlayout.h for
  2469.                 more information.
  2470.                 Default: NULL
  2471.  
  2472.             LAIN_Activate (BOOL) - When the window opens, make this
  2473.                 gadget the active one.
  2474.  
  2475.                     NOTE: There can be only one gadget of this type
  2476.                         per window.
  2477.  
  2478.                 Default: FALSE
  2479.                 (requires gtlayout.library v21 or higher)
  2480.  
  2481.  
  2482.         STRING_KIND:
  2483.  
  2484.             LAST_LastGadget (BOOL) - Pressing return with this
  2485.                 gadget active will stop activating the next
  2486.                 following string gadget type if TRUE is passed.
  2487.                 Default: FALSE
  2488.  
  2489.             LAST_Link (LONG) - Gadget ID of the listview to attach
  2490.                 this string gadget to.
  2491.  
  2492.                     NOTE: you need to add the string gadget before
  2493.                         you add the listview to refer to it or the
  2494.                         layout routine will get confused.
  2495.  
  2496.             LAST_Picker (BOOL) - Attach a `select' button to the
  2497.                 right hand side of the string gadget.
  2498.                 Default: FALSE
  2499.  
  2500.             LAST_HistoryLines (LONG) - Number of lines to keep as
  2501.                 a backlog.
  2502.                 Default: 0
  2503.  
  2504.             LAST_HistoryHook (struct Hook *) - Hook code to call
  2505.                 when entering a line into the backlog. See gtlayout.h
  2506.                 for more information.
  2507.                 Default: NULL
  2508.  
  2509.             LAST_Activate (BOOL) - When the window opens, make this
  2510.                 gadget the active one.
  2511.  
  2512.                     NOTE: There can be only one gadget of this type
  2513.                         per window.
  2514.  
  2515.                 Default: FALSE
  2516.                 (requires gtlayout.library v21 or higher)
  2517.  
  2518.         PASSWORD_KIND (string gadget type which does not
  2519.             display its contents):
  2520.  
  2521.             LAPW_LastGadget (BOOL) - Pressing return with this
  2522.                 gadget active will stop activating the next
  2523.                 following string gadget type if TRUE is passed.
  2524.                 Default: FALSE
  2525.  
  2526.             LAPW_HistoryLines (LONG) - Number of lines to keep as
  2527.                 a backlog.
  2528.                 Default: 0
  2529.  
  2530.             LAPW_HistoryHook (struct Hook *) - Hook code to call
  2531.                 when entering a line into the backlog. See gtlayout.h
  2532.                 for more information.
  2533.                 Default: NULL
  2534.  
  2535.             LAPW_Activate (BOOL) - When the window opens, make this
  2536.                 gadget the active one.
  2537.  
  2538.                     NOTE: There can be only one gadget of this type
  2539.                         per window.
  2540.  
  2541.                 Default: FALSE
  2542.                 (requires gtlayout.library v21 or higher)
  2543.  
  2544.             This object type accepts all the GTST_#? tag items.
  2545.  
  2546.  
  2547.         PALETTE_KIND:
  2548.  
  2549.             LAPA_SmallPalette (BOOL) - Make the palette display
  2550.                 a bit smaller than usual.
  2551.                 Default: FALSE
  2552.  
  2553.             LAPA_Lines (LONG) - Number of lines the palette
  2554.                 display should cover.
  2555.                 Default: No preference
  2556.  
  2557.             LAPA_UsePicker (BOOL) - This tag effectively changes the
  2558.                 gadget type. Instead of a list of colours to pick from
  2559.                 the user will see a rectangle filled in the selected
  2560.                 colour with a picker button next to it. This gadget
  2561.                 will generate IDCMP_IDCMPUPDATE events when the picker
  2562.                 button is pressed.
  2563.                 (requires gtlayout.library v10 or higher)
  2564.  
  2565.  
  2566.         BUTTON_KIND:
  2567.  
  2568.             LA_Label (STRPTR)
  2569.             LA_LabelID (LONG) - These two define the button label, i.e.
  2570.                 the text that is printed within the button box. Optionally,
  2571.                 this text may include newline characters ("\n") which will
  2572.                 cause the button text to be broken into several lines.
  2573.                 This particular feature requires gtlayout.library v12 or
  2574.                 higher. Single line label have always been supported.
  2575.  
  2576.             LABT_ReturnKey (BOOL) - Let the user operate this
  2577.                 button by pressing the return key, making it the
  2578.                 so-called default button, or default choice. The
  2579.                 button select box will appear slightly bolder than
  2580.                 normal buttons are.
  2581.  
  2582.                     NOTE: there can be only one single button per
  2583.                         window to sport this feature.
  2584.  
  2585.                 Default: FALSE
  2586.  
  2587.             LABT_EscKey (BOOL) - Let the user operate this
  2588.                 button by pressing the Escape key.
  2589.  
  2590.                     NOTE: there can be only one single button per
  2591.                         window to use this feature.
  2592.  
  2593.                 Default: FALSE
  2594.  
  2595.             LABT_ExtraFat (BOOL) - Make this button a bit
  2596.                 larger than usual.
  2597.                 Default: FALSE
  2598.  
  2599.             LABT_Lines (STRPTR *) - Use the given string array
  2600.                 to create a multiline gadget label. Terminate the
  2601.                 array with a NULL.
  2602.                 (requires gtlayout.library v12 or higher)
  2603.  
  2604.             LABT_FirstLine (LONG) - Locale ID of first label line.
  2605.                 (requires gtlayout.library v12 or higher)
  2606.  
  2607.             LABT_LastLine (LONG) - Locale ID of last label line.
  2608.                 (requires gtlayout.library v12 or higher)
  2609.  
  2610.             LABT_DefaultCorrection (BOOL) - Make the button slightly
  2611.                 wider and taller so its size matches the default
  2612.                 button.
  2613.                 (requires gtlayout.library v21 or higher)
  2614.  
  2615.             LABT_Smaller (BOOL) - Make this button a little smaller
  2616.                 than usual.
  2617.                 (requires gtlayout.library v21 or higher)
  2618.  
  2619.         GAUGE_KIND (general purpose progress report display):
  2620.  
  2621.             LAGA_Percent (LONG) - Indicator position, can range
  2622.                 from 0..100.
  2623.                 Default: 0
  2624.  
  2625.             LAGA_InfoLength (LONG) - Maximum number of characters
  2626.                 to reserve for text printed in the gauge display.
  2627.                 Default: 0
  2628.  
  2629.             LAGA_InfoText (STRPTR) - Text to print in the gauge
  2630.                 display.
  2631.  
  2632.             LAGA_Tenth (BOOL) - Instead of a continuously growing
  2633.                 bar you will get a set of exactly ten blocks,
  2634.                 each separated by a hairline.
  2635.                 Default: FALSE
  2636.                 (requires gtlayout.library v19 or higher)
  2637.  
  2638.  
  2639.         CYCLE_KIND:
  2640.  
  2641.             LACY_FirstLabel (LONG) - Locale string ID of the first
  2642.                 text to use as a label. Works in conjunction
  2643.                 with LACY_LastLabel.
  2644.  
  2645.             LACY_LastLabel (LONG) - Locale string ID of the last
  2646.                 text to use as a label. Works in conjunction
  2647.                 with LACY_FirstLabel. When building the interface the
  2648.                 code will loop from FirstLabel..LastLabel, look
  2649.                 up the corresponding locale strings and use the
  2650.                 data to make up the label text.
  2651.  
  2652.             LACY_LabelTable (LONG *) - Pointer to an array of IDs
  2653.                 to use for building the cycle labels. This requires
  2654.                 that a locale hook is provided with the layout handle.
  2655.                 The array is terminated by -1.
  2656.  
  2657.             LACY_TabKey (BOOL) - Connect this object to the tabulator
  2658.                 key. Press [Tab] to cycle to the next entry, [Shift][Tab]
  2659.                 to cycle to the previous entry.
  2660.  
  2661.                     NOTE: there can be only one single button per
  2662.                         window to use this feature.
  2663.  
  2664.                 Default: FALSE
  2665.                 (requires gtlayout.library v9 or higher)
  2666.  
  2667.             LACY_AutoPageID (LONG) - ID of paged GROUP_KIND object
  2668.                 which will be set to the gadget's current setting.
  2669.                 (requires gtlayout.library v7 or higher)
  2670.  
  2671.                     NOTE: Listen to IDCMP_CLOSEWINDOW events
  2672.                         which may be generated if the layout
  2673.                         engine runs out of memory when rebuilding
  2674.                         the user interface.
  2675.  
  2676.  
  2677.         POPUP_KIND:
  2678.  
  2679.             (This features requires gtlayout.library v22 or higher
  2680.              and Kickstart 3.0 or higher).
  2681.  
  2682.             LAPU_FirstLabel (LONG) - Locale string ID of the first
  2683.                 text to use as a label. Works in conjunction
  2684.                 with LAPU_LastLabel.
  2685.  
  2686.             LAPU_LastLabel (LONG) - Locale string ID of the last
  2687.                 text to use as a label. Works in conjunction
  2688.                 with LAPU_FirstLabel. When building the interface the
  2689.                 code will loop from FirstLabel..LastLabel, look
  2690.                 up the corresponding locale strings and use the
  2691.                 data to make up the label text.
  2692.  
  2693.             LAPU_LabelTable (LONG *) - Pointer to an array of IDs
  2694.                 to use for building the cycle labels. This requires
  2695.                 that a locale hook is provided with the layout handle.
  2696.                 The array is terminated by -1.
  2697.  
  2698.             LAPU_TabKey (BOOL) - Connect this object to the tabulator
  2699.                 key. Press [Tab] to cycle to the next entry, [Shift][Tab]
  2700.                 to cycle to the previous entry.
  2701.  
  2702.                     NOTE: there can be only one single button per
  2703.                         window to use this feature.
  2704.  
  2705.                 Default: FALSE
  2706.  
  2707.             LAPU_AutoPageID (LONG) - ID of paged GROUP_KIND object
  2708.                 which will be set to the gadget's current setting.
  2709.  
  2710.                     NOTE: Listen to IDCMP_CLOSEWINDOW events
  2711.                         which may be generated if the layout
  2712.                         engine runs out of memory when rebuilding
  2713.                         the user interface.
  2714.  
  2715.             LAPU_CentreActive (BOOL) - If TRUE, the popup menu will
  2716.                 appear with the currently active entry centred below
  2717.                 the mouse pointer.
  2718.                 (requires gtlayout.library v31 or higher)
  2719.  
  2720.         TAB_KIND:
  2721.  
  2722.             (This features requires gtlayout.library v24 or higher)
  2723.  
  2724.             LATB_FirstLabel (LONG) - Locale string ID of the first
  2725.                 text to use as a label. Works in conjunction
  2726.                 with LATB_LastLabel.
  2727.  
  2728.             LATB_LastLabel (LONG) - Locale string ID of the last
  2729.                 text to use as a label. Works in conjunction
  2730.                 with LATB_FirstLabel. When building the interface the
  2731.                 code will loop from FirstLabel..LastLabel, look
  2732.                 up the corresponding locale strings and use the
  2733.                 data to make up the label text.
  2734.  
  2735.             LATB_LabelTable (LONG *) - Pointer to an array of IDs
  2736.                 to use for building the cycle labels. This requires
  2737.                 that a locale hook is provided with the layout handle.
  2738.                 The array is terminated by -1.
  2739.  
  2740.             LATB_TabKey (BOOL) - Connect this object to the tabulator
  2741.                 key. Press [Tab] to cycle to the next entry, [Shift][Tab]
  2742.                 to cycle to the previous entry.
  2743.  
  2744.                     NOTE: there can be only one single button per
  2745.                         window to use this feature.
  2746.  
  2747.                 Default: FALSE
  2748.  
  2749.             LATB_AutoPageID (LONG) - ID of paged GROUP_KIND object
  2750.                 which will be set to the gadget's current setting.
  2751.  
  2752.                     NOTE: Listen to IDCMP_CLOSEWINDOW events
  2753.                         which may be generated if the layout
  2754.                         engine runs out of memory when rebuilding
  2755.                         the user interface.
  2756.  
  2757.             LATB_FullSize (BOOL) - By default a TAB_KIND object
  2758.                 covers the entire width of the group it sits in.
  2759.                 With LATB_FullSize set to true it will cover the
  2760.                 width of the entire Window.
  2761.  
  2762.                 Default: FALSE
  2763.  
  2764.  
  2765.         MX_KIND:
  2766.  
  2767.             LAMX_FirstLabel (LONG) - Locale string ID of the first
  2768.                 text to use as a label. Works in conjunction
  2769.                 with LAMX_LastLabel.
  2770.  
  2771.             LAMX_LastLabel (LONG) - Locale string ID of the last
  2772.                 text to use as a label. Works in conjunction
  2773.                 with LAMX_FirstLabel. When building the interface the
  2774.                 code will loop from FirstLabel..LastLabel, look
  2775.                 up the corresponding locale strings and use the
  2776.                 data to make up the label text.
  2777.  
  2778.             LAMX_LabelTable (LONG *) - Pointer to an array of IDs
  2779.                 to use for building the radio labels. This requires
  2780.                 that a locale hook is provided with the layout handle.
  2781.                 The array is terminated by -1.
  2782.  
  2783.             LAMX_TabKey (BOOL) - Connect this object to the tabulator
  2784.                 key. Press [Tab] to cycle to the next entry, [Shift][Tab]
  2785.                 to cycle to the previous entry.
  2786.  
  2787.                     NOTE: there can be only one single button per
  2788.                         window to use this feature.
  2789.  
  2790.                 Default: FALSE
  2791.                 (requires gtlayout.library v9 or higher)
  2792.  
  2793.             LAMX_AutoPageID (LONG) - ID of paged GROUP_KIND object
  2794.                 which will be set to the gadget's current setting.
  2795.                 (requires gtlayout.library v7 or higher)
  2796.  
  2797.                     NOTE: Listen to IDCMP_CLOSEWINDOW events
  2798.                         which may be generated if the layout
  2799.                         engine runs out of memory when rebuilding
  2800.                         the user interface.
  2801.  
  2802.  
  2803.         SCROLLER_KIND:
  2804.  
  2805.             LASC_Thin (BOOL) - Make the scroller a bit thinner
  2806.                 than usual.
  2807.                 Default: FALSE
  2808.  
  2809.             GA_RelVerify (BOOL) - Hear every IDCMP_GADGETUP
  2810.                 event from scroller.
  2811.                 Default: TRUE
  2812.  
  2813.                         NOTE: This is different from what
  2814.                          gadtools.library uses.
  2815.  
  2816.             GA_Immediate (BOOL) - Hear every IDCMP_GADGETDOWN
  2817.                 event from scroller
  2818.                 Default: TRUE
  2819.  
  2820.                         NOTE: This is different from what
  2821.                          gadtools.library uses.
  2822.  
  2823.         TAPEDECK_KIND:
  2824.  
  2825.             LATD_ButtonType (LONG) - Select the image to display
  2826.                 in the button, must be one of the following:
  2827.  
  2828.                     TDBT_BACKWARD
  2829.                         "<<" Symbol
  2830.  
  2831.                     TDBT_FORWARD
  2832.                         ">>" Symbol
  2833.  
  2834.                     TDBT_PREVIOUS
  2835.                         "|<" Symbol
  2836.  
  2837.                     TDBT_NEXT
  2838.                         ">|" Symbol
  2839.  
  2840.                     TDBT_STOP
  2841.                         Stop symbol (filled square)
  2842.  
  2843.                     TDBT_PAUSE
  2844.                         "||" pause symbol (broken square)
  2845.  
  2846.                     TDBT_RECORD
  2847.                         Record symbol (filled circle)
  2848.  
  2849.                     TDBT_REWIND
  2850.                         "<" symbol
  2851.  
  2852.                     TDBT_EJECT
  2853.                         Eject symbol (broken upward pointing arrow)
  2854.  
  2855.                     TDBT_PLAY
  2856.                         ">" symbol
  2857.  
  2858.             LATD_Toggle (BOOL) - Make this object a toggle-select
  2859.                 button.
  2860.                 Default: FALSE
  2861.  
  2862.             LATD_Pressed (BOOL) - Make this button appear to be
  2863.                 pressed.
  2864.  
  2865.                     NOTE: requires "LATD_Toggle,TRUE" attribute.
  2866.  
  2867.                 Default: FALSE
  2868.  
  2869.             LATD_Smaller (BOOL) - Make this button a bit smaller
  2870.                 than usual.
  2871.                 Default: FALSE
  2872.  
  2873.             LATD_Tick (BOOL) - Hear IDCMP_GADGETUP events while the
  2874.                 buttons is being pressed; the IntuiMessage->Code entry
  2875.                 will be 0 while the button is being pressed, and
  2876.                 will be 1 as soon as the button is released.
  2877.  
  2878.                 Default: FALSE
  2879.  
  2880.                 (requires gtlayout.library v12 or higher)
  2881.  
  2882.  
  2883.         BOOPSI_KIND:
  2884.  
  2885.             (requires gtlayout.library v10 or higher)
  2886.  
  2887.             LABO_TagCurrent (Tag) - The Tag ID that represents the
  2888.                 current object value. For PROPGCLASS this would be
  2889.                 PGA_Top.
  2890.  
  2891.             LABO_TagTextAttr (Tag) - The Tag ID that represents the
  2892.                 TextAttr value the object expects. For gadgets this
  2893.                 would be GA_TextAttr.
  2894.  
  2895.             LABO_TagDrawInfo (Tag) - The Tag ID that represents the
  2896.                 DrawInfo value the object expects.
  2897.  
  2898.             LABO_TagLink (Tag) - The Tag ID that represents a pointer
  2899.                 to a different object the object expects. For the
  2900.                 colorwheel.gadget this would be WHEEL_GradientSlider.
  2901.  
  2902.             LABO_TagScreen (Tag) - The Tag ID that represents the
  2903.                 screen the object expects. For the colorwheel.gadget
  2904.                 this would be WHEEL_Screen.
  2905.  
  2906.             LABO_Link (LONG) - The ID of the object this object should
  2907.                 be linked to. This will be resolved later when gadgets
  2908.                 are created.
  2909.  
  2910.                     NOTE: Forward references are not resolved, only
  2911.                         backward references are allowed. This means that
  2912.                         if you wish to link object A to object B,
  2913.                         object A must be created before object B
  2914.                         is created.
  2915.  
  2916.             LABO_ClassInstance (Class *) - This is the first parameter
  2917.                 you would pass to NewObjectA().
  2918.  
  2919.                     NOTE: Only classes derived from gadgetclass and
  2920.                       gadgetclass itself may be used.
  2921.  
  2922.             LABO_ClassName (STRPTR) - This is the second parameter you would
  2923.                 pass to NewObject().
  2924.  
  2925.                     NOTE: Only classes derived from gadgetclass and
  2926.                         gadgetclass itself may be used.
  2927.  
  2928.             LABO_ClassLibraryName (STRPTR) - This tag is particularly useful
  2929.                 for gadget class implementations wrapped into libraries, such as
  2930.                 colorwheel.gadget. When opened, they make the classes they
  2931.                 represent publicly available so subsequent calls to
  2932.                 NewObject(NULL,<Classname>,...) can be made. The
  2933.                 LABO_ClassLibraryName tag will cause gtlayout.library to open
  2934.                 the class library before any calls to NewObject() are made.
  2935.  
  2936.                     NOTE: Only classes derived from gadgetclass and
  2937.                         gadgetclass itself may be used.
  2938.  
  2939.                         The LABO_ClassLibraryName tag requires that you
  2940.                         specify the class name with the LABO_ClassName. It is
  2941.                         not enough to just use the LABO_ClassLibraryName tag.
  2942.  
  2943.             LABO_ExactWidth (WORD) - This is the exact width of the object to
  2944.                 use. This effectively overrides whatever you specified using
  2945.                 the LA_Chars tag and keeps gtlayout.library from shrinking and
  2946.                 expanding the object as needed.
  2947.  
  2948.             LABO_ExactHeight (WORD) - This is the exact height of the object to
  2949.                 use. This effectively overrides whatever you specified using
  2950.                 the LA_Lines tag and keeps gtlayout.library from shrinking and
  2951.                 expanding the object as needed.
  2952.  
  2953.             LABO_RelFontHeight (WORD) - This tag affects the height of the
  2954.                 object; when specified, it is derived from the user interface
  2955.                 font height plus the value given with LABO_RelFontHeight.
  2956.  
  2957.             LABO_FullWidth (BOOL) - Use this tag if you wish the object to
  2958.                 cover the entire width of the group it resides within.
  2959.  
  2960.             LABO_FullHeight (BOOL) - Use this tag if you wish the object to
  2961.                 cover the entire height of the group it resides within.
  2962.  
  2963.             LABO_ActivateHook (struct Hook *) - Hook to invoke when the
  2964.                 layout engine decides that this particular object should
  2965.                 be activated. The hook is called with the following
  2966.                 parameters:
  2967.  
  2968.                 Success = ActivateFunc(struct Hook *Hook,LayoutHandle *Handle,
  2969.                   D0                                 A0                  A2
  2970.  
  2971.                              Object *object)
  2972.                                        A1
  2973.  
  2974.                 The object pointer actually refers to the instance of the
  2975.                 BOOPSI object created. Return FALSE if your object could not
  2976.                 be activated, TRUE if it worked. If you return TRUE, no special
  2977.                 keyboard event will be generated.
  2978.  
  2979.                 (requires gtlayout.library v13 or higher)
  2980.  
  2981.             NOTE: All tags passed to LT_New() for BOOPSI_KIND objects are
  2982.                 passed through to NewObjectA() later. The library makes
  2983.                 a copy of the tag item list, so all data valid in the
  2984.                 scope when LT_New() is called must also be valid later
  2985.                 when LT_Build() is invoked.
  2986.  
  2987.                 The gadget label is *NOT* passed through to the object,
  2988.                 it effectively receives the label a plain gadtools object
  2989.                 would receive, similar to what happens to FRAME_KIND
  2990.                 objects and the like.
  2991.  
  2992.    RESULT
  2993.     none
  2994.  
  2995.    BUGS
  2996.     Up to v25 the SCROLLER_KIND object did not support GA_Immediate
  2997.     or GA_RelVerify. The space for the variables was there, but the
  2998.     code was missing.
  2999.  
  3000.     POPUP_KIND objects don't work well in simple refresh windows,
  3001.     as refresh events can get lost. Use a smart refresh window
  3002.     instead.
  3003.  
  3004.    SEE ALSO
  3005.     gadtools.library/CreateGadgetA
  3006.  
  3007. gtlayout.library/LT_NewLevelWidth           gtlayout.library/LT_NewLevelWidth
  3008.  
  3009.    NAME
  3010.     LT_NewLevelWidth -- Determine the maximum width of a SLIDER_KIND
  3011.                         level string. (V14)
  3012.  
  3013.    SYNOPSIS
  3014.     Index = LT_LevelWidth(Handle,FormatString,DispFunc,Min,Max,MaxWidth,
  3015.       D0                    A0        A1         A2     D0  D1    A3
  3016.  
  3017.                               MaxLen,FullCheck);
  3018.                                 D3      D2
  3019.  
  3020.     LONG LT_LevelWidth(LayoutHandle *,STRPTR,
  3021.                        LONG (*)(struct Gadget *,WORD),LONG,LONG,LONG *,
  3022.                        LONG *,BOOL);
  3023.  
  3024.    FUNCTION
  3025.     In order to make room for the level text displayed by a
  3026.     SLIDER_KIND object one needs to know how much space the
  3027.     longest level string will occupy. Otherwise, the level
  3028.     text may overwrite the gadget label text or the slider
  3029.     container. This routine will rattle through all possible
  3030.     slider settings (as given via the Min and the Max
  3031.     level values) and determine the longest label string
  3032.     according to the font used.
  3033.  
  3034.    INPUTS
  3035.     Handle - Pointer to a LayoutHandle structure, as returned by
  3036.         a call to LT_CreateHandleTags().
  3037.  
  3038.     FormatString - The sprintf() style formatting string to be used
  3039.         to format the slider level settings into text.
  3040.         This is the same string you would pass in via
  3041.         the GTSL_LevelFormat tag when creating the
  3042.         slider object.
  3043.         Default: "%lD" for systems which have locale.library
  3044.             installed, "%ld" otherwise.
  3045.  
  3046.     DispFunc - A pointer to the function to filter the slider level
  3047.         values. The result of this function will then be
  3048.         used to format a string into the slider level text.
  3049.         This is the same parameter you would pass in via
  3050.         the GTSL_DispFunc tag when creating the slider
  3051.         object.
  3052.  
  3053.         NOTE: the routine will be called with a NULL Gadget
  3054.             parameter, make sure your code will handle
  3055.             this nicely.
  3056.  
  3057.         Default: no display function
  3058.  
  3059.     Min - The smallest value the slider can be set to. This is
  3060.         same value you would pass in via GTSL_Min when creating
  3061.         the slider object.
  3062.  
  3063.     Max - The largest value the slider can be set to. This is
  3064.         same value you would pass in via GTSL_Max when creating
  3065.         the slider object.
  3066.  
  3067.     MaxWidth - Pointer to a place to store the width of the
  3068.         longest level string in pixels. If you pass
  3069.         in NULL instead of the address of a variable
  3070.         no harm will be done.
  3071.  
  3072.     MaxLen - Pointer to a place to store the length of the
  3073.         longest level string in characters. If you pass
  3074.         in NULL instead of the address of a variable
  3075.         no harm will be done.
  3076.  
  3077.     FullCheck - TRUE will cause the code to rattle through all
  3078.         possible slider settings, starting from the
  3079.         minimum value, ending at the maximum value.
  3080.         While this may be a good idea for a display
  3081.         function to map slider levels to text strings
  3082.         of varying length it might be a problem when
  3083.         it comes to display a range of numbers from
  3084.         1 to 40,000: the code will loop through
  3085.         40,000 iterations trying to find the longest
  3086.         string.
  3087.  
  3088.         FALSE will cause the code to calculate the
  3089.         longest level string based only on the
  3090.         minimum and the maximum value to check.
  3091.         While this is certainly a good a idea when
  3092.         it comes to display a range of numbers from
  3093.         1 to 40,000 as only two values will be
  3094.         checked the code may fail to produce
  3095.         accurate results for sliders using display
  3096.         functions mapping slider levels to strings.
  3097.  
  3098.    RESULT
  3099.     Index - The slider level which gives the longest
  3100.         level string.
  3101.  
  3102.    NOTES
  3103.     This function does exactly what gtlayout.library/LT_LevelWidth
  3104.     does, but uses a slightly different register ordering. Namely,
  3105.     the MaxLen pointer is passed in D3 instead of A5.
  3106.  
  3107.    SEE ALSO
  3108.     gtlayout.library/LT_LevelWidth
  3109.  
  3110. gtlayout.library/LT_NewMenuTagList         gtlayout.library/LT_NewMenuTagList
  3111.  
  3112.    NAME
  3113.     LT_NewMenuTagList -- Allocate and layout menu items (V11)
  3114.  
  3115.    SYNOPSIS
  3116.     Menu = LT_NewMenuTagList(Tags)
  3117.      D0                       A0
  3118.  
  3119.     struct Menu *LT_NewMenuTagList(struct TagItem *);
  3120.  
  3121.     struct Menu *LT_NewMenuTags(...);
  3122.  
  3123.    FUNCTION
  3124.     Allocates Menus and MenuItems similar to LT_LayoutMenus().
  3125.  
  3126.     As of v18 this routine will validate menu mutual exclusion
  3127.     information.
  3128.  
  3129.    INPUTS
  3130.     Tags - Pointer to a list of tagitem values, as found
  3131.         in gtlayout.h
  3132.  
  3133.  
  3134.     Valid tags include:
  3135.  
  3136.     LAMN_Screen (struct Screen *) - Pointer to the Screen
  3137.         the menu is to appear upon. This tag is mandatory,
  3138.         unless the LAMN_LayoutHandle tag is used.
  3139.  
  3140.     LAMN_TextAttr (struct TextAttr *) - Pointer to the
  3141.         TextAttr to use for the menu layout. If this tag
  3142.         is omitted the Screen->Font will be used.
  3143.  
  3144.     LAMN_Error (LONG *) - Pointer to variable to receive
  3145.         an error in case of failure.
  3146.  
  3147.     LAMN_AmigaGlyph (struct Image *) - Pointer to Image to
  3148.         use as the Amiga glyph in menus. Will be ignored if
  3149.         NULL.
  3150.  
  3151.         NOTE: Ignored by intuition.library v37 and below.
  3152.  
  3153.     LAMN_CheckmarkGlyph (struct Image *) - Pointer to Image to
  3154.         use as the checkmark glyph in menus. Will be ignored
  3155.         if NULL.
  3156.  
  3157.     LAMN_LayoutHandle (LayoutHandle *) - Pointer to a valid
  3158.         LayoutHandle as created by LT_CreateHandle. This tag
  3159.         provides all the information the single tags
  3160.         LAMN_Screen..LAMN_CheckmarkGlyph would otherwise
  3161.         need to provide.
  3162.  
  3163.     LAMN_TitleText (STRPTR) - Name of new menu to create.
  3164.         You may precede the name with the keyboard shortcut
  3165.         to assign to this menu item as follows:
  3166.  
  3167.            A\0Save as...
  3168.  
  3169.         This will create a menu item using the shortcut "A"
  3170.         and the title "Save as...".
  3171.  
  3172.     LAMN_TitleID (LONG) - Locale ID corresponding to the
  3173.         name of the new menu to create.
  3174.         You may precede the name with the keyboard shortcut
  3175.         to assign to this menu item as follows:
  3176.  
  3177.            A\0Save as...
  3178.  
  3179.         This will create a menu item using the shortcut "A"
  3180.         and the title "Save as...".
  3181.  
  3182.     LAMN_ItemText (STRPTR) - Name of new menu item to create.
  3183.         You may precede the name with the keyboard shortcut
  3184.         to assign to this menu item as follows:
  3185.  
  3186.            A\0Save as...
  3187.  
  3188.         This will create a menu item using the shortcut "A"
  3189.         and the title "Save as...".
  3190.  
  3191.     LAMN_ItemID (LONG) - Locale ID corresponding to the
  3192.         name of the new menu item to create.
  3193.         You may precede the name with the keyboard shortcut
  3194.         to assign to this menu item as follows:
  3195.  
  3196.            A\0Save as...
  3197.  
  3198.         This will create a menu item using the shortcut "A"
  3199.         and the title "Save as...".
  3200.  
  3201.     LAMN_SubText (STRPTR) - Name of new submenu item to create.
  3202.         You may precede the name with the keyboard shortcut
  3203.         to assign to this menu item as follows:
  3204.  
  3205.            A\0Save as...
  3206.  
  3207.         This will create a menu item using the shortcut "A"
  3208.         and the title "Save as...".
  3209.  
  3210.     LAMN_SubID (LONG) - Locale ID corresponding to the
  3211.         name of the new submenu item to create.
  3212.         You may precede the name with the keyboard shortcut
  3213.         to assign to this menu item as follows:
  3214.  
  3215.            A\0Save as...
  3216.  
  3217.         This will create a menu item using the shortcut "A"
  3218.         and the title "Save as...".
  3219.  
  3220.     LAMN_KeyText (STRPTR) - Pointer to the string whose first
  3221.         character will be used as the keyboard shortcut for
  3222.         this menu/submenu item.
  3223.  
  3224.     LAMN_KeyID (LONG) - Locale ID corresponding to the string whose
  3225.         first character will be used as the keyboard shortcut for
  3226.         this menu/submenu item.
  3227.  
  3228.     LAMN_CommandText (STRPTR) - Pointer to the string which
  3229.         will be used as the keyboard shortcut for this
  3230.         menu/submenu item.
  3231.  
  3232.     LAMN_CommandID (LONG) - Locale ID corresponding to the string
  3233.         which will be used as the keyboard shortcut for
  3234.         this menu/submenu item.
  3235.  
  3236.     LAMN_MutualExclude (ULONG) - Mutual exclusion information for
  3237.         this menu/submenu item.
  3238.  
  3239.     LAMN_UserData (APTR) - User data information for this
  3240.         menu/menu item/submenu item.
  3241.  
  3242.     LAMN_Disabled (BOOL) - Controls whether this
  3243.         menu/menu item/submenu item should be disabled.
  3244.  
  3245.     LAMN_CheckIt (BOOL) - Controls whether this menu/submenu item
  3246.         should be prepared to hold a checkmark.
  3247.  
  3248.             NOTE: This does not set the checkmark, use LAMN_Checked
  3249.                 for this purpose.
  3250.  
  3251.     LAMN_Checked (BOOL) - Controls whether this menu/submenu item
  3252.         should be marked with a checkmark. This tag implies
  3253.         "LAMN_Checked,TRUE".
  3254.  
  3255.     LAMN_Toggle (BOOL) - Controls whether this menu/submenu item
  3256.         should be prepared to hold a checkmark the user is to
  3257.         toggle on demand. This tag implies "LAMN_Checked,TRUE".
  3258.  
  3259.             NOTE: this does not set the checkmark, use LAMN_Checked
  3260.                 for this purpose.
  3261.  
  3262.     LAMN_Code (UWORD) - Raw key code to associate with this
  3263.         menu/submenu item. To find out if a rawkey event
  3264.         corresponds to this menu item use LT_FindMenuCommand.
  3265.  
  3266.     LAMN_Qualifier (ULONG) - Key qualifier to associate
  3267.         with this menu/submenu item.
  3268.  
  3269.             NOTE: the comparison does not distinguish between
  3270.                 the left and right shift/caps/alt qualifier keys.
  3271.  
  3272.     LAMN_ID (ULONG) - Unique ID to associate with this
  3273.         menu/menu item/submenu item. You can use this
  3274.         later to look up data using LT_GetMenuItem, etc.
  3275.  
  3276.     LAMN_ExtraSpace (UWORD) - Number of pixels to put between
  3277.         neighbouring menu titles.
  3278.         Default: 0 pixels.
  3279.  
  3280.         (requires gtlayout.library v18 or higher)
  3281.  
  3282.    RESULT
  3283.     Menu - Pointer to Menu structure, ready to pass to
  3284.            SetMenuStrip(), NULL on failure.
  3285.  
  3286.    EXAMPLE
  3287.     The following tagitem list:
  3288.  
  3289.         LAMN_TitelText,     "Project"
  3290.          LAMN_ItemText,     "New",
  3291.           LAMN_KeyText,     "N",
  3292.          LAMN_ItemText,     "Open...",
  3293.           LAMN_KeyText,     "O",
  3294.          LAMN_ItemText,     NM_BARLABEL,
  3295.          LAMN_ItemText,     "Save",
  3296.           LAMN_KeyText,     "S",
  3297.          LAMN_ItemText,     "A\0Save As...",
  3298.          LAMN_ItemText,     NM_BARLABEL,
  3299.          LAMN_ItemText,     "Print...",
  3300.           LAMN_KeyText,     "P",
  3301.          LAMN_ItemText,     NM_BARLABEL,
  3302.          LAMN_ItemText,     "Help...",
  3303.           LAMN_CommandText, "[Help]",
  3304.          LAMN_ItemText,     NM_BARLABEL,
  3305.          LAMN_ItemText,     "Quit...",
  3306.           LAMN_KeyText,     "Q",
  3307.         TAG_DONE
  3308.  
  3309.     Will create the following menu:
  3310.  
  3311.     +-------+
  3312.     |Project|
  3313.     +-------+------+
  3314.     |New         aN|
  3315.     |Open...     aO|
  3316.     |~~~~~~~~~~~~~~|
  3317.     |Save        aS|
  3318.     |Save As...  aA|
  3319.     |~~~~~~~~~~~~~~|
  3320.     |Print...    aP|
  3321.     |~~~~~~~~~~~~~~|
  3322.     |Help... [Help]|
  3323.     |~~~~~~~~~~~~~~|
  3324.     |Quit...     aQ|
  3325.     +--------------+
  3326.  
  3327.    NOTES
  3328.     You may freely add, remove, spindle & mutilate the contents of the
  3329.     menu strip created, just don't trash or disconnect the base menu
  3330.     entry this routine creates as all menu memory tracking data is
  3331.     connected to it.
  3332.  
  3333.    SEE ALSO
  3334.     gtlayout.library/LT_DisposeMenu
  3335.     gtlayout.library/LT_FindCommandItem
  3336.     gtlayout.library/LT_GetMenuItem
  3337.     gtlayout.library/LT_LayoutMenuA
  3338.     gtlayout.library/LT_MenuControlTagList
  3339.     gtlayout.library/LT_NewMenuTemplate
  3340.     intuition.library/SetMenuStrip
  3341.  
  3342. gtlayout.library/LT_NewMenuTemplate       gtlayout.library/LT_NewMenuTemplate
  3343.  
  3344.    NAME
  3345.     LT_NewMenuTemplate -- Allocate and layout menu items (V11)
  3346.  
  3347.    SYNOPSIS
  3348.     Menu = LT_NewMenuTemplate(Screen,TextAttr,AmigaGlyph,CheckmarkGlyph,
  3349.      D0                         A0      A1        A2           A3
  3350.  
  3351.                               Error,MenuTemplate);
  3352.                                 D0      D1
  3353.  
  3354.     struct Menu *LT_NewMenuTemplate(struct Screen *,struct TextAttr *,
  3355.                                     struct Image *,struct Image *,
  3356.                                     LONG *,struct NewMenu *);
  3357.  
  3358.    FUNCTION
  3359.     Allocates Menus and MenuItems similar to LT_LayoutMenus().
  3360.  
  3361.     As of v18 this routine will validate menu mutual exclusion
  3362.     information.
  3363.  
  3364.    INPUTS
  3365.     Screen - Pointer to the screen the menu will appear on. This
  3366.         parameter is required and must not be omitted.
  3367.  
  3368.     TextAttr - Pointer to the TextAttr that should be used to
  3369.         layout the menus. If this parameter is omitted,
  3370.         Screen->Font will be used instead.
  3371.  
  3372.     AmigaGlyph - Pointer to the Image to use as the Amiga glyph.
  3373.         This parameter may be omitted.
  3374.  
  3375.             NOTE: Ignored by intuition.library v37 and below.
  3376.  
  3377.     CheckmarkGlyph - Pointer to the Image to use as the checkmark
  3378.         glyph. This parameter may be omitted.
  3379.  
  3380.     Error - Pointer to receive error code in case the menu
  3381.         creation or layout process fails. This parameter
  3382.         may be omitted.
  3383.  
  3384.     MenuTemplate - Pointer to a series of NewMenu structures,
  3385.         just as you would pass to
  3386.         gtlayout.library/LT_LayoutMenuA.
  3387.  
  3388.    RESULT
  3389.     Menu - Pointer to Menu structure, ready to pass to
  3390.         SetMenuStrip(), NULL on failure.
  3391.  
  3392.    NOTES
  3393.     The menu created by this function cannot be used with the
  3394.     routines LT_MenuControlTagList, LT_FindMenuCommand and
  3395.     LT_GetMenuItem.
  3396.  
  3397.     You may freely add, remove, spindle & mutilate the contents of the
  3398.     menu strip created, just don't trash or disconnect the base menu
  3399.     entry this routine creates as all menu memory tracking data is
  3400.     connected with it.
  3401.  
  3402.    SEE ALSO
  3403.     gtlayout.library/LT_DisposeMenu
  3404.     gtlayout.library/LT_LayoutMenuA
  3405.     gtlayout.library/LT_NewMenuTagList
  3406.     intuition.library/SetMenuStrip
  3407.  
  3408. gtlayout.library/LT_PressButton               gtlayout.library/LT_PressButton
  3409.  
  3410.    NAME
  3411.     LT_PressButton -- Highlight a button so it looks as if the user
  3412.                       has selected it.
  3413.  
  3414.    SYNOPSIS
  3415.     LT_PressButton(Handle,ID);
  3416.                       A0  D0
  3417.  
  3418.     VOID LT_PressButton(LayoutHandle *,LONG);
  3419.  
  3420.    FUNCTION
  3421.     You can provide visual feedback for BUTTON_KIND objects by calling
  3422.     this routine. They will briefly appear to be selected and then
  3423.     fall back to their original states.
  3424.  
  3425.    INPUTS
  3426.     Handle - Pointer to LayoutHandle structure
  3427.  
  3428.     ID - ID of button object to highlight
  3429.  
  3430.    RESULT
  3431.     none
  3432.  
  3433. gtlayout.library/LT_RebuildTagList         gtlayout.library/LT_RebuildTagList
  3434.  
  3435.    NAME
  3436.     LT_RebuildTagList -- Rebuild the user interface after modifying it.
  3437.  
  3438.    SYNOPSIS
  3439.     Success = LT_RebuildTagList(Handle,Clear,TagList);
  3440.        D0                         A0    D0     A1
  3441.  
  3442.     BOOL LT_RebuildTagList(LayoutHandle *,BOOL,struct TagItem *);
  3443.  
  3444.     Success = LT_RebuildTags(Handle,Clear,...);
  3445.  
  3446.     BOOL LT_RebuildTags(LayoutHandle *,BOOL,...);
  3447.  
  3448.    FUNCTION
  3449.     Certain aspects of the user interface can be changed at run time,
  3450.     such as button labels. This routine will let you rebuild the interface
  3451.     based upon the data supplied at creation time and your subsequent
  3452.     changes. Before you make any vital changes, it is recommended to
  3453.     lock the window using LT_LockWindow() in order to avoid clashes
  3454.     with the Intuition and GadTools subsystems.
  3455.  
  3456.    INPUTS
  3457.     Handle - Pointer to LayoutHandle structure.
  3458.  
  3459.     Clear - Pass in TRUE if you wish to have the window contents
  3460.         cleared before they are rebuild. This will introduce
  3461.         some visual hashing.
  3462.  
  3463.     TagList - Attributes controlling the layout process.
  3464.  
  3465.  
  3466.     Valid tags include:
  3467.  
  3468.     LAWN_Bounds (struct IBox *) - Boundaries in which the window
  3469.         should be centered.
  3470.  
  3471.     LAWN_ExtraWidth (LONG) - Extra space to add to the window
  3472.         width.
  3473.  
  3474.     LAWN_ExtraHeight (LONG) - Extra height to add to the window
  3475.         height.
  3476.  
  3477.    RESULT
  3478.     Success - TRUE indicates that the interface was rebuilt,
  3479.         FALSE indicates trouble; it is recommended to
  3480.         call LT_DeleteHandle() on your LayoutHandle as
  3481.         soon as possible as the previous operation may
  3482.         have left the user interface in an inoperable
  3483.         state.
  3484.  
  3485. gtlayout.library/LT_Refresh                       gtlayout.library/LT_Refresh
  3486.  
  3487.    NAME
  3488.     LT_Refresh -- Redraws the entire window contents.
  3489.  
  3490.    SYNOPSIS
  3491.     LT_Refresh(Handle)
  3492.                  A0
  3493.  
  3494.     VOID LT_Refresh(LayoutHandle *);
  3495.  
  3496.    FUNCTION
  3497.     Redraws the contents of the window, this includes both gadgets
  3498.     and imagery.
  3499.  
  3500.    INPUTS
  3501.     Handle - Pointer to a LayoutHandle structure.
  3502.  
  3503.    RESULT
  3504.     none
  3505.  
  3506.    SEE ALSO
  3507.        gadtools.library/GT_RefreshWindow
  3508.        intuition.library/RefreshGList
  3509.  
  3510. gtlayout.library/LT_ReplyIMsg                   gtlayout.library/LT_ReplyIMsg
  3511.  
  3512.    NAME
  3513.     LT_ReplyIMsg -- Dispose of an IntuiMessage received
  3514.  
  3515.    SYNOPSIS
  3516.     LT_ReplyIMsg(IntuiMessage);
  3517.                      A0
  3518.  
  3519.     VOID LT_ReplyIMsg(struct IntuiMessage *);
  3520.  
  3521.    FUNCTION
  3522.     This routine complements LT_GetIMsg().
  3523.  
  3524.    INPUTS
  3525.     IntuiMessage - Pointer to IntuiMessage structure,
  3526.         passing NULL is harmless.
  3527.  
  3528.    RESULT
  3529.     none
  3530.  
  3531.    NOTES
  3532.     Only pass IntuiMessages you received via LT_GetIMsg,
  3533.     or things will get tough.
  3534.  
  3535.    SEE ALSO
  3536.     gtlayout.library/LT_GetIMsg
  3537.  
  3538. gtlayout.library/LT_SetAttributesA         gtlayout.library/LT_SetAttributesA
  3539.  
  3540.    NAME
  3541.     LT_SetAttributesA -- Change object attributes
  3542.  
  3543.    SYNOPSIS
  3544.     LT_SetAttributesA(Handle,ID,Tags);
  3545.                         A0   D0  A1
  3546.  
  3547.     VOID LT_SetAttributes(LayoutHandle *,LONG,struct TagItem *);
  3548.  
  3549.     LT_SetAttributes(Handle,ID,...);
  3550.  
  3551.     VOID LT_SetAttributes(LayoutHandle *,LONG,...);
  3552.  
  3553.    FUNCTION
  3554.     This routine passes the tag item list it gets directly
  3555.     over to GT_SetGadgetAttrsA(), so any tag items valid for
  3556.     gadtools.library can be used here as well. Some filtering
  3557.     may be done in order to stop objects from getting redrawn
  3558.     if this is not absolutely necessary.
  3559.  
  3560.    INPUTS
  3561.     Handle - Pointer to LayoutHandle.
  3562.  
  3563.     ID - ID number of the object to change. This is the same value
  3564.         you passed via LA_ID to LT_New() when you created this object.
  3565.  
  3566.     Tags - Attributes controlling object states.
  3567.  
  3568.  
  3569.     All gadtools.library tags are allowed, but not all are supported.
  3570.     In addition to these tags a few additional tag values are
  3571.     supported:
  3572.  
  3573.     LAHN_AutoActivate (BOOL) - Set to TRUE if you want the interface
  3574.         to always keep a string gadget active if possible. Hitting
  3575.         the return key will then cause the next following string
  3576.         gadget to get activated, either cycling through all the
  3577.         string gadgets available or stopping at the next string
  3578.         gadget to have the LAST_LastGadget attribute set.
  3579.  
  3580.     LAHN_UserData (APTR) - Store user specific data in the
  3581.         LayoutHandle->UserData entry.
  3582.         (requires gtlayout.library v9 or higher)
  3583.  
  3584.     LAHN_RawKeyFilter (BOOL) - Discard unprocessed IDCMP_RAWKEY
  3585.         events.
  3586.         Default: TRUE
  3587.         (requires gtlayout.library v13 or higher)
  3588.  
  3589.     LAHN_LocaleHook (struct Hook *) - The hook to call when
  3590.         locale string IDs are to be mapped to strings. The
  3591.         hook function is called with the following parameters:
  3592.  
  3593.         String = HookFunc(struct Hook *Hook,struct LayoutHandle *Handle,
  3594.           D0                            A0                         A2
  3595.                           LONG ID)
  3596.                                A1
  3597.  
  3598.         The function is to look up the string associated with the ID
  3599.         passed in and return the string.
  3600.  
  3601.     LAHN_ExitFlush (BOOL) - When the LayoutHandle is finally disposed
  3602.         of with LT_DeleteHandle() all variables maintained by the
  3603.         input handling code will be flushed. For example, if you
  3604.         would use the LA_STRPTR tag for STRING_KIND objects the
  3605.         last string gadget contents would be copied into the buffer
  3606.         pointed to by LA_STRPTR. If you do not want to use this
  3607.         feature, disable it with "LAHN_ExitFlush,FALSE".
  3608.         Default: TRUE
  3609.         (requires gtlayout.library v9 or higher)
  3610.  
  3611.     GAUGE_KIND:
  3612.  
  3613.         LAGA_Percent (LONG) - Percentage of the gauge to fill.
  3614.  
  3615.         LAGA_InfoText (STRPTR) - Text to be printed within the
  3616.             gauge display, such as a percentage number.
  3617.  
  3618.     BOX_KIND:
  3619.  
  3620.         LABX_Index (LONG) - The number of the line to change, this
  3621.             tag works in conjunction with the LABX_Text tag.
  3622.  
  3623.         LABX_Text (STRPTR) - The text to put into the line indicated
  3624.             by the LABX_Index tag.
  3625.             As of v26 the LABX_Index tag may be omitted, the library
  3626.             will then assume the line index will be 0.
  3627.  
  3628.         LABX_Lines (STRPTR *) - The text to set for the box contents,
  3629.             terminate the text array with NULL.
  3630.  
  3631.     HORIZONTAL_KIND:
  3632.     VERTICAL_KIND:
  3633.  
  3634.         LAGR_ActivePage (LONG) - Index number of page to display
  3635.             within the group.
  3636.  
  3637.                 NOTE: requires that this group was created
  3638.                     with the LAGR_ActivePage attribute set.
  3639.  
  3640.     FRACTION_KIND:
  3641.  
  3642.         LAFC_Number (FIXED) - Fixed point number to use
  3643.  
  3644.         LAFC_Min (FIXED) - Minimum allowed value for this
  3645.             object.
  3646.  
  3647.         LAFC_Max (FIXED) - Maximum allowed value for this
  3648.             object.
  3649.  
  3650.     INTEGER_KIND:
  3651.  
  3652.         LAIN_Min (LONG) - Minimum allowed value for this
  3653.             object.
  3654.  
  3655.         LAIN_Max (LONG) - Maximum allowed value for this
  3656.             object.
  3657.  
  3658.     PASSWORD_KIND:
  3659.  
  3660.         LAPW_String (STRPTR) - Secret text to use
  3661.  
  3662.     POPUP_KIND
  3663.  
  3664.         LAPU_Labels (STRPTR *) - To block access to the popup
  3665.             menu, for example before you free the current list
  3666.             of labels, you can pass ~0 as the list parameter.
  3667.             (requires gtlayout.library v25 or higher)
  3668.  
  3669.     STRING_KIND:
  3670.  
  3671.         LAST_CursorPosition (LONG) - Repositions the cursor,
  3672.             pass -1 to move it to the end of the string.
  3673.             (requires gtlayout.library v7 or higher)
  3674.  
  3675.     TAPEDECK_KIND:
  3676.  
  3677.         LATD_Pressed (BOOL) - TRUE to make this button shown
  3678.             as pressed, FALSE to show it in depressed state.
  3679.  
  3680.     BOOPSI_KIND:
  3681.  
  3682.         All tags are passed straight through to SetGadgetAttrs(..).
  3683.  
  3684.     All objects:
  3685.  
  3686.         LA_LabelText (STRPTR) - New gadget label text to use.
  3687.  
  3688.         LA_LabelID (LONG) - Locale text ID to use for this object.
  3689.  
  3690.    RESULT
  3691.     none
  3692.  
  3693.    SEE ALSO
  3694.     gadtools.library/GT_SetGadgetAttrsA()
  3695.     intuition.library/SetGadgetAttrsA
  3696.  
  3697. gtlayout.library/LT_ShowWindow                 gtlayout.library/LT_ShowWindow
  3698.  
  3699.    NAME
  3700.     LT_ShowWindow -- Make a window visible
  3701.  
  3702.    SYNOPSIS
  3703.     LT_ShowWindow(Handle,Activate);
  3704.                     A0      A1
  3705.  
  3706.     VOID LT_ShowWindow(LayoutHandle *,BOOL);
  3707.  
  3708.    FUNCTION
  3709.     The window attached to a LayoutHandle is made visible, this
  3710.     involves bringing it to the front, bringing the screen to
  3711.     the front the window resides on, unzooming the window and
  3712.     also moving the visible part of an autoscrolling screen.
  3713.  
  3714.    INPUTS
  3715.     Window - Pointer to Window structure.
  3716.  
  3717.     Activate - If TRUE the window will be activated as soon
  3718.         as it has been brought to the front.
  3719.  
  3720.    RESULT
  3721.     none
  3722.  
  3723.    NOTES
  3724.     The arguments are passed in A0 and A1, this is *not* a
  3725.     typo.
  3726.  
  3727.    BUGS
  3728.     In revisions earlier than v21 this routine consistently
  3729.     failed to reliably unzip a window in zoomed state. This
  3730.     could cause the calling application to wait for about
  3731.     five seconds before continuing execution.
  3732.  
  3733.    SEE ALSO
  3734.     intuition.library/MoveScreen
  3735.     intuition.library/ScreenPosition
  3736.     intuition.library/ZipWindow
  3737.  
  3738. gtlayout.library/LT_String2Fixed             gtlayout.library/LT_String2Fixed
  3739.  
  3740.    NAME
  3741.     LT_String2Fixed -- Convert an ASCII string into a fixed-point numeric
  3742.                        value.
  3743.  
  3744.    SYNOPSIS
  3745.     Fixed = LT_String2Fixed(String)
  3746.       D0                      A0
  3747.  
  3748.     FIXED LT_String2Fixed(STRPTR);
  3749.  
  3750.    FUNCTION
  3751.     This routine complements LT_Fixed2String, it implements a
  3752.     service similar to atof() in converting an ASCII string
  3753.     into a fixed-point number.
  3754.  
  3755.    INPUTS
  3756.     String - Pointer to null-terminated string.
  3757.  
  3758.    RESULT
  3759.     Fixed - Fixed-point number; will be 0.0 if non-numeric
  3760.         characters are found in the input string.
  3761.  
  3762.    NOTES
  3763.     The decimal point to look for will be taken from the
  3764.     current locale settings. If locale.library is not
  3765.     installed, the `.' character will be used instead.
  3766.  
  3767.    BUGS
  3768.     Works reliably, but the entire FIXED datatype operations
  3769.     are broken due to design faults.
  3770.  
  3771. gtlayout.library/LT_UnlockWindow             gtlayout.library/LT_UnlockWindow
  3772.  
  3773.    NAME
  3774.     LT_UnlockWindow -- The complement to LT_LockWindow().
  3775.  
  3776.    SYNOPSIS
  3777.     LT_UnlockWindow(Window);
  3778.                       A0
  3779.  
  3780.     VOID LT_UnlockWindow(struct Window *);
  3781.  
  3782.    FUNCTION
  3783.     This routine unlocks a window locked using LT_LockWindow, freeing
  3784.     allocated memory, restoring the window characteristics to their
  3785.     original values.
  3786.  
  3787.    INPUTS
  3788.     Window - Pointer to window structure; passing NULL is harmless.
  3789.  
  3790.    RESULT
  3791.     none
  3792.  
  3793.    SEE ALSO
  3794.     gtlayout.library/LT_LockWindow
  3795.  
  3796. gtlayout.library/LT_UpdateStrings           gtlayout.library/LT_UpdateStrings
  3797.  
  3798.    NAME
  3799.     LT_UpdateStrings -- Make sure all visible string buffer contents
  3800.                         get written into storage (v9).
  3801.  
  3802.    SYNOPSIS
  3803.     LT_UpdateStrings(LayoutHandle);
  3804.                             A0
  3805.  
  3806.     VOID LT_UpdateStrings(struct LayoutHandle *);
  3807.  
  3808.    FUNCTION
  3809.     The user can terminate input into a string gadget or an object
  3810.     derived from a string gadget by various means. They all have
  3811.     in common that the application receives no notification that
  3812.     the string gadget contents have changed. This is particularly
  3813.     nasty with objects which make use of LA_STRPTR or other
  3814.     tags. Using LT_UpdateStrings() you can force all visible string
  3815.     gadget objects to hand over their contents to the internal
  3816.     buffers. Do this before you eventually exit your input loop.
  3817.  
  3818.    INPUTS
  3819.     LayoutHandle - Pointer to LayoutHandle structure.
  3820.  
  3821.    RESULT
  3822.     none
  3823.  
  3824.